Karaktereak maneiatzeko funtzio gehiago

Jarraian karaktereak lantzeko funtzio batzuk deskribatzen dira. Ez dira funtzio estandarrak eta ctype.h, liburutegia behar dute.

Funtzio horiek guk geuk programa ditzakegu zailtasun larregirik gabe, ondoko kode batzuetan erakusten den bezala.

int isdigit(int ch);

isdigit() funtzioak zeroz bestelako balio bat itzultzen du, baldin eta ch parametroa 0 eta 9 artekoa bada. Beste edozein kasutan, zero itzultzen du.

/* ISDIGIT_funtzioa.cbp */
// getche() funtzioak zenbaki oso bat itzultzen du, karakterearen ASCII balioa
// isdigit() funtzioak zenbaki oso bat itzultzen du 0 eta 9 bada, karakterearen ASCII balioa

#include <stdio.h>
#include <conio.h>   // getche() funtziorako
#include <ctype.h>   // isdigit() funtziorako
#include <stdbool.h> // bool datu-motarako

bool fnboDigituaDa(char);

int main()
{
   char cDatua;
   int iDigitua = 0;
   int iBestelakoa = 0;
   int iDigituak = 0;
   int iBestelakoak = 0;

   printf("\n\n Digituak irakurtzen...");
   printf("\n");
   do
   {
       printf("\n Digitu bat eman. Amaitzeko '%%' sartu: ");
       cDatua=getche();

       if (isdigit(cDatua) != 0)
           iDigitua++;
       else
           iBestelakoa++;

       if (fnboDigituaDa(cDatua) == true)
           iDigituak++;
       else
           iBestelakoak++;
   }
   while (cDatua != '%');

   printf("\n");
   printf("\n isdigit() --------> Eman diren digituen kopurua: %d", iDigitua);
   printf("\n isdigit() --------> Digituak ez direnen kopurua: %d", iBestelakoa);
   printf("\n");
   printf("\n fnboDigituaDa() --> Eman diren digituen kopurua: %d", iDigituak);
   printf("\n fnboDigituaDa() --> Digituak ez direnen kopurua: %d", iBestelakoak);

   printf("\n\n");
   return 0;


bool fnboDigituaDa(char cDatua)
{
    if (('0' <= cDatua) && ('9' >= cDatua))
        return(true);
    else
        return(false);
}

int isalpha(int ch);

isalpha() funtzioak zeroz bestelako balio bat itzultzen du baldin eta ch parametroa alfabetoko letra bada. Bestela, zero balioa bat itzultzen du.

/* ISALPHA_funtzioa.cbp */
// getche() funtzioak zenbaki oso bat itzultzen du, karakterearen ASCII balioa
// isalpha() funtzioak zenbaki oso bat itzultzen du alfabetikoa bada, karakterearen ASCII balioa

#include <stdio.h>
#include <conio.h>   // getche() funtziorako
#include <ctype.h>   // isalpha() funtziorako
#include <stdbool.h> // bool datu-motarako

bool fnboAlfabetikoaDa(char);

int main()
{
   char cDatua;
   int iAlfabetikoa = 0;
   int iBestelakoa = 0;
   int iAlfabetikoak = 0;
   int iBestelakoak = 0;

   printf("\n\n Karaktereak irakurtzen...");
   printf("\n");
   do
   {
       printf("\n Alfabetoko letra bat eman. Amaitzeko '%%' sartu: ");
       cDatua=getche();

       if (isalpha(cDatua) != 0)
           iAlfabetikoa++;
       else
           iBestelakoa++;

       if (fnboAlfabetikoaDa(cDatua) == true)
           iAlfabetikoak++;
       else
           iBestelakoak++;
   }
   while (cDatua != '%');

   printf("\n");
   printf("\n isalpha() ------------> Emandako alfabetoko letren kopurua: %d", iAlfabetikoa);
   printf("\n isalpha() ------------> Alfabetokoak ez direnen zenbatekoa: %d", iBestelakoa);

   printf("\n");
   printf("\n fnboAlfabetikoaDa() --> Emandako alfabetoko letren kopurua: %d", iAlfabetikoak);
   printf("\n fnboAlfabetikoaDa() --> Alfabetokoak ez direnen zenbatekoa: %d", iBestelakoak);

   printf("\n\n");
   return 0;
}


bool fnboAlfabetikoaDa(char cDatua)
{
    if ((('a' <= cDatua) && ('z' >= cDatua)) ||
        (('A' <= cDatua) && ('Z' >= cDatua)))
        return(true);
    else
        return(false);
}

int islower(int ch);

islower() funtzioak zeroz bestelako balio bat itzultzen du baldin eta ch parametroa alfabeto minuskulako letra bada. Bestela, zero balioa bat itzultzen du.

/* ISLOWER_funtzioa.cbp */
// getche() funtzioak zenbaki oso bat itzultzen du, karakterearen ASCII balioa
// islower() funtzioak zenbaki oso bat itzultzen du letra minuskula bada, karakterearen ASCII balioa

#include <stdio.h>
#include <conio.h>   // getche() funtziorako
#include <ctype.h>   // islower() funtziorako
#include <stdbool.h> // bool datu-motarako

bool fnboMinuskulaDa(char);

int main()
{
   char cDatua;
   int iMinuskula = 0;
   int iBestelakoa = 0;
   int iMinuskulak = 0;
   int iBestelakoak = 0;

   printf("\n\n Karaktereak irakurtzen...");
   printf("\n");
   do
   {
       printf("\n Alfabetoko letra minuskula bat eman. Amaitzeko '%%' sartu: ");
       cDatua=getche();

       if (islower(cDatua) != 0)
           iMinuskula++;
       else
           iBestelakoa++;

       if (fnboMinuskulaDa(cDatua) == true)
           iMinuskulak++;
       else
           iBestelakoak++;
   }
   while (cDatua != '%');

   printf("\n");
   printf("\n islower() ----------> Emandako minuskululen kopurua: %d", iMinuskula);
   printf("\n islower() ----------> Minuskulak ez direnen kopurua: %d", iBestelakoa);

   printf("\n");
   printf("\n fnboMinuskulaDa() --> Emandako minuskululen kopurua: %d", iMinuskulak);
   printf("\n fnboMinuskulaDa() --> Minuskulak ez direnen kopurua: %d", iBestelakoak);

   printf("\n\n");
   return 0;
}


bool fnboMinuskulaDa(char cDatua)
{
    if (('a' <= cDatua) && ('z' >= cDatua))
        return(true);
    else
        return(false);
}

int isupper(int ch);

isupper() funtzioak zeroz bestelako balio bat itzultzen du baldin eta ch parametroa alfabeto larriko letra bada. Bestela, zero balioa bat itzultzen du.

/* ISUPPER_funtzioa.cbp */
// getche() funtzioak zenbaki oso bat itzultzen du, karakterearen ASCII balioa
// isupper() funtzioak zenbaki oso bat itzultzen du letra larria bada, karakterearen ASCII balioa

#include <stdio.h>
#include <conio.h>   // getche() funtziorako
#include <ctype.h>   // isupper() funtziorako
#include <stdbool.h> // bool datu-motarako

bool fnboLarriaDa(char);

int main()
{
   char cDatua;
   int iLarria = 0;
   int iBestelakoa = 0;
   int iLarriak = 0;
   int iBestelakoak = 0;

   printf("\n\n Karaktereak irakurtzen...");
   printf("\n");
   do
   {
       printf("\n Alfabetoko letra larri bat eman. Amaitzeko '%%' sartu: ");
       cDatua=getche();

       if (isupper(cDatua) != 0)
           iLarria++;
       else
           iBestelakoa++;

       if (fnboLarriaDa(cDatua) == true)
           iLarriak++;
       else
           iBestelakoak++;
   }
   while (cDatua != '%');

   printf("\n");
   printf("\n isupper() ---------> Eman diren larrien kopurua: %d", iLarria);
   printf("\n isupper() ---------> Larriak ez direnen kopurua: %d", iBestelakoa);

   printf("\n");
   printf("\n fnboLarriaDa() ----> Eman diren larrien kopurua: %d", iLarriak);
   printf("\n fnboLarriaDa() ----> Larriak ez direnen kopurua: %d", iBestelakoak);

   printf("\n\n");
   return 0;
}


bool fnboLarriaDa(char cDatua)
{
    if (('A' <= cDatua) && ('Z' >= cDatua))
        return(true);
    else
        return(false);
}

int tolower(int ch);

tolower() funtzioak ch parametroaren baliokidea letra xehez itzultzen du, baldin eta ch parametroa letra larria bada. Bestela, beste edozein kasutan ch itzultzen du aldatu gabe.

/* TOLOWER_funtzioa.cbp */
// getche() funtzioak zenbaki oso bat itzultzen du, karakterearen ASCII balioa
// tolower() funtzioak zenbaki oso bat itzultzen du, karakterearen ASCII balioa

#include <stdio.h>
#include <conio.h>   // getche() funtziorako
#include <ctype.h>   // tolower() funtziorako

char fncLarritikXehera(char);

ihar cLarritikXehera(char);

int main()
{
   char cDatua;
   char cXehea;
   char cMinuskula;

   printf("\n\n Karaktereak irakurtzen...");
   printf("\n");
   do
   {
       printf("\n Alfabetoko letra larri bat eman. Amaitzeko '%%' sartu: ");
       cDatua=getche();

       cXehea = tolower(cDatua);
       printf("\n tolower()           %c -----> %c", cDatua, cXehea);
       cMinuskula = cLarritikXehera(cDatua);
       printf("\n cLarritikXehera()   %c -----> %c", cDatua, cMinuskula);
       printf("\n");
   }
   while (cDatua != '%');

   printf("\n");
   return 0;
}


char cLarritikXehera(char cDatua)
{
    char cEmaitza;

    if (('A' <= cDatua) && ('Z' >= cDatua))
    {
        cEmaitza = cDatua + 32;
        return(cEmaitza);
    }
    else
        return(cDatua);
}


char fncLarritikXehera(char cDatua)
{
    char cEmaitza;

    if (('A' <= cDatua) && ('Z' >= cDatua))
    {
        cEmaitza = (char)(cDatua + 32);
        return(cEmaitza);
    }
    else
        return(cDatua);
}

int toupper(int ch);

toupper() funtzioak ch parametroaren baliokidea letra larriz itzultzen du, baldin eta ch parametroa letra xehea bada. Bestela, beste edozein kasutan ch itzultzen du aldatu gabe.

/* TOLOWER_funtzioa.cbp */
// getche() funtzioak zenbaki oso bat itzultzen du, karakterearen ASCII balioa
// toupper() funtzioak zenbaki oso bat itzultzen du, karakterearen ASCII balioa

#include <stdio.h>
#include <conio.h>   // getche() funtziorako
#include <ctype.h>   // toupper() funtziorako

char cXehetikLarrira(char);

int main()
{
   char cDatua;
   char cLarria;
   char cMajuskula;

   printf("\n\n Karaktereak irakurtzen...");
   printf("\n");
   do
   {
       printf("\n Alfabetoko letra xehe bat eman. Amaitzeko '%%' sartu: ");
       cDatua=getche();

       cLarria = toupper(cDatua);
       printf("\n toupper()           %c -----> %c", cDatua, cLarria);
       cMajuskula = cXehetikLarrira(cDatua);
       printf("\n cXehetikLarrira()   %c -----> %c", cDatua, cMajuskula);
       printf("\n");
   }
   while (cDatua != '%');

   printf("\n");
   return 0;
}


char cXehetikLarrira(char cDatua)
{
    char cEmaitza;

    if (('a' <= cDatua) && ('z' >= cDatua))
    {
        cEmaitza = cDatua - 32;
        return(cEmaitza);
    }
    else
        return(cDatua);
}


char fncXehetikLarrira(char cDatua)
{
    char cEmaitza;

    if (('a' <= cDatua) && ('z' >= cDatua))
    {
        cEmaitza = (char)(cDatua - 32);
        return(cEmaitza);
    }
    else
        return(cDatua);
}

int isalnum(int ch);

isalnum() funtzioak zeroz bestelako balio bat itzultzen du baldin eta ch parametroa alfanumerikoa bada (alfabetoko letra bat edo digitu bat). Bestela, zero balioa bat itzultzen du.

/* ISALNUM_funtzioa.cbp */
// getche() funtzioak zenbaki oso bat itzultzen du, karakterearen ASCII balioa
// isalnum() funtzioak zenbaki oso bat itzultzen du alfanumerikoa bada, karakterearen ASCII balioa

#include <stdio.h>
#include <conio.h>   // getche() funtziorako
#include <ctype.h>   // isalnum() funtziorako

int main()
{
   char cDatua;
   int iAlfaNumerikoa = 0;
   int iBestelakoa = 0;

   printf("\n\n Karaktereak irakurtzen...");
   printf("\n");
   do
   {
       printf("\n Alfabetoko letra bat edo digitu bat eman. Amaitzeko '%%' sartu: ");
       cDatua=getche();

       if (isalnum(cDatua) != 0)
           iAlfaNumerikoa++;
       else
           iBestelakoa++;
   }
   while (cDatua != '%');

   printf("\n");
   printf("\n Eman diren alfanumerikoen kopurua: %d", iAlfaNumerikoa);
   printf("\n Alfanumerikoak ez direnen kopurua: %d", iBestelakoa);

   printf("\n\n");
   return 0;
}

int isgraph(int ch);

isgraph() funtzioak zeroz bestelako balio bat itzultzen du, baldin eta ch parametroa inprimagarria bada (espazioa izan ezik). Beste edozein kasutan (espazioarekin ere), zero itzultzen du.

/* ISGRAPH_funtzioa.cbp */
// getche() funtzioak zenbaki oso bat itzultzen du, karakterearen ASCII balioa
// isgraph() funtzioak zenbaki oso bat itzultzen du inprimagarria bada, karakterearen ASCII balioa

#include <stdio.h>
#include <conio.h>   // getche() funtziorako
#include <ctype.h>   // isgraph() funtziorako

int main()
{
   char cDatua;
   int iInprimagarria = 0;
   int iBestelakoa = 0;

   printf("\n\n Karaktereak irakurtzen...");
   printf("\n");
   do
   {
       printf("\n Karaktere bat eman. Amaitzeko '%%' sartu: ");
       cDatua=getche();

       if (isgraph(cDatua) != 0)
           iInprimagarria++;
       else
           iBestelakoa++;
   }
   while (cDatua != '%');

   printf("\n");
   printf("\n Eman diren inprimagarrien kopurua: %d", iInprimagarria);
   printf("\n Inprimagarriak ez direnen kopurua: %d", iBestelakoa);

   printf("\n\n");
   return 0;
}

int isprint(int ch);

isprint() funtzioak zeroz bestelako balio bat itzultzen du, baldin eta ch parametroa inprimagarria bada (espazioa barne). Beste edozein kasutan, zero itzultzen du.

/* ISPRINT_funtzioa.cbp */
// getche() funtzioak zenbaki oso bat itzultzen du, karakterearen ASCII balioa
// isprint() funtzioak zenbaki oso bat itzultzen du inprimagarria bada, karakterearen ASCII balioa

#include <stdio.h>
#include <conio.h>   // getche() funtziorako
#include <ctype.h>   // isprint() funtziorako

int main()
{
   char cDatua;
   int iInprimagarria = 0;
   int iBestelakoa = 0;

   printf("\n\n Karaktereak irakurtzen...");
   printf("\n");
   do
   {
       printf("\n Karaktere bat eman. Amaitzeko '%%' sartu: ");
       cDatua=getche();

       if (isprint(cDatua) != 0)
           iInprimagarria++;
       else
           iBestelakoa++;
   }
   while (cDatua != '%');

   printf("\n");
   printf("\n Eman diren inprimagarrien kopurua: %d", iInprimagarria);
   printf("\n Inprimagarriak ez direnen kopurua: %d", iBestelakoa);

   printf("\n\n");
   return 0;
}

int isspace(int ch);

isspace() funtzioak zeroz bestelako balio bat itzultzen du, baldin eta ch parametroa espazio bat bada, tabuladorea bada, edo lerro-jauziko karakterea bada. Beste edozein kasutan, zero itzultzen du.

/* ISSPACE_funtzioa.cbp */
// getche() funtzioak zenbaki oso bat itzultzen du, karakterearen ASCII balioa
// isspace() funtzioak zenbaki oso bat itzultzen du espazioa, tabuladorea eta lerro-jauzia bada, karakterearen ASCII balioa

#include <stdio.h>
#include <conio.h>   // getche() funtziorako
#include <ctype.h>   // isspace() funtziorako

int main()
{
   char cDatua;
   int iEspazioa = 0;
   int iBestelakoa = 0;

   printf("\n\n Karaktereak irakurtzen...");
   printf("\n");
   do
   {
       printf("\n Espazio motako karaktere bat eman. Amaitzeko '%%' sartu: ");
       cDatua=getche();

       if (isspace(cDatua) != 0)
           iEspazioa++;
       else
           iBestelakoa++;
   }
   while (cDatua != '%');

   printf("\n");
   printf("\n Eman diren espazioen kopurua: %d", iEspazioa);
   printf("\n Espazioak ez direnen kopurua: %d", iBestelakoa);

   printf("\n\n");
   return 0;
}