karaktere etiketadun mezuak erakusten. Erakutsi mezu guztiak
karaktere etiketadun mezuak erakusten. Erakutsi mezu guztiak

2025(e)ko otsailaren 19(a), asteazkena

Ariketa 36 | Hainbat aukeren menu bat

ZER DAKIDAN:
switch baldintzazko egitura ikasi nuen aukera anitzak antolatzeko.



ZER IKASIKO DUDAN:
Menu bat programa batean nola egiten den ikasiko dut, erabiltzaileak gogoko duen hautapena char datu-motako aldagai batean irakurriko dut. Bide batez system("cls") errutinaren funtzionamendua ikusiko dut ere. Eta, noski, menu bat prozesu errepikakor bat izan ohi da eta bertatik irteteko propio idaztiko dut aukera bat.


Ariketa 18 | Aukera anitzen arteko hautapena artikulua gogora ekarriz, programaren fluxua bideratzeko switch agindua erabilten da aukerak hiru edo gehiago direnean.

Jarraian erakusten den menua programa nagusian kokaturik dago, baina jakin ezazu hori horrela ez dela egingo behin azpiprogramen kontzeptua gureganatuko dugunetik aurrera.

Algoritmoa:
  1. Programa osoa prozesu errepikakor bat da, eta errepikapenak mozteko menuaren aukera egokia hautatu behar da (lehen adibidean I, i edo 0 balioak, eta bigarren adibidean A edo a balioak)
  2. Begiztaren iterazio bakoitzeko, pantaila garbitu system("cls") funtzioaren bitartez eta bost aukeren deskribapenak erakutsi
  3. Begiztaren iterazio bakoitzeko, char datu-motako cAukera aldagaiari balioa teklatuz eman era kontrolatuan (teklatuaren karaktere bat irakurtzeko getche() funtzioa oso egokia da)
  4. Irakurri den karaktere horren arabera switch egiturak kudeatuko du programaren fluxoa eta aukera horri dagozkion kalkuluak burutuko dira
  5. Begiztaren iterazio bakoitzeko, programaren exekuzioa gelditu getch() funtzioaren bitartez tekla bat sakatu arte, horrela informazioa eta kalkuluen emaitzak ikusi ahal izango dira
Ondoko bi programak nahiko berdintsuak dira, batean konstanteak erakusten dira pantailan eta bestean kalkulu baten emaitza. Bi ariketetan garrantzitsuena da programa nola antolatu den.


Programa honek goiko algoritmoa aplikatzen du:

/* Ariketa-36a_MenuBat: hainbat aukeren menu bat, aukeratzailea char */

// Programa hau 'Ariketa-18_MenuBat' programaren jarraipena da,
// harekiko dituen hobekuntzak:
//    1. Aldagai aukeratzailea char datu-motakoa da
//    2. Aldagai aukeratzailea irakurtzean egokitasuna kontrolatzen da
//    3. Iterazio bakoitzean pantaila garbitzen da
//    4. Menuak irteteko aukera du

#include <stdio.h>
#include <stdlib.h>   // system() funtziorako
#include <conio.h>    // getche() eta getch() funtzioetarako

#define LAT_A -34.927499   // Adelaide
#define LON_A 138.600000
#define LAT_B -15.793889   // Brasilia
#define LON_B -47.882778
#define LAT_C 51.047500    // Calgary
#define LON_C -114.062500
#define LAT_D 48.008889    // Donetsk
#define LON_D 37.804167

int main()
{
   char cAukera;

   do
   {
       system("cls");
       printf("\n");
       printf("\n ======Hiri baten datuak======");
       printf("\n     A. Adelaide");
       printf("\n     B. Brasilia");
       printf("\n     C. Calgary");
       printf("\n     D. Donetsk");
       printf("\n\n     I. Programatik irten");
       printf("\n =============================");

       do
       {
           printf("\n Zure aukera: ");
           cAukera = getche();
           fflush(stdin);
       } while ((cAukera != 'A') && (cAukera != 'a') &&
                (cAukera != 'B') && (cAukera != 'b') &&
                (cAukera != 'C') && (cAukera != 'c') &&
                (cAukera != 'D') && (cAukera != 'd') &&
                (cAukera != 'I') && (cAukera != 'i'));

       printf("\n");

       switch(cAukera)
       {
           case 'A':
           case 'a':
               printf("\n Adelaide");
               printf("\n Koordenatuak: (%.6f, %.6f)", LAT_A, LON_A);
               printf("\n Hego hemisferioko ekialdea");
               break;
           case 'B':
           case 'b':
               printf("\n Brasilia");
               printf("\n Koordenatuak: (%.6f, %.6f)", LAT_B, LON_B);
               printf("\n Hego hemisferioko mendebaldea");
               break;
           case 'C':
           case 'c':
               printf("\n Calgary");
               printf("\n Koordenatuak: (%.6f, %.6f)", LAT_C, LON_C);
               printf("\n Ipar hemisferioko mendebaldea");
               break;
           case 'D':
           case 'd':
               printf("\n Donetsk");
               printf("\n Koordenatuak: (%.6f, %.6f)", LAT_D, LON_D);
               printf("\n Ipar hemisferioko ekialdea");
               break;
           default:
               printf("\n Irtetera goaz.");
       }  // switch

       if ((cAukera != 'I') && (cAukera != 'i'))
       {
           printf("\n\n Edozein tekla sakatu aurrera egiteko...");
           getch();   // pantailaratutako informazioa ikusi ahal izateko
       }
   } while ((cAukera != 'I') && (cAukera != 'i'));

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

Programa honek ere goiko algoritmoa aplikatzen du:

/* Ariketa-36a2_MenuBat: hainbat aukeren menu bat, aukeratzailea int */

// Programa hau 'Ariketa-18_MenuBat' programaren jarraipena da,
// harekiko dituen hobekuntzak:
//    1. Aldagai aukeratzailea char datu-motakoa da
//    2. Aldagai aukeratzailea irakurtzean egokitasuna kontrolatzen da
//    3. Iterazio bakoitzean pantaila garbitzen da
//    4. Menuak irteteko aukera du

#include <stdio.h>
#include <stdlib.h>   // system() funtziorako
#include <conio.h>    // getche() eta getch() funtzioetarako

#define LAT_A -34.927499   // Adelaide
#define LON_A 138.600000
#define LAT_B -15.793889   // Brasilia
#define LON_B -47.882778
#define LAT_C 51.047500    // Calgary
#define LON_C -114.062500
#define LAT_D 48.008889    // Donetsk
#define LON_D 37.804167

int main()
{
   int iAukera;

   do
   {
       system("cls");
       printf("\n");
       printf("\n ======Hiri baten datuak======");
       printf("\n     1. Adelaide");
       printf("\n     2. Brasilia");
       printf("\n     3. Calgary");
       printf("\n     4. Donetsk");
       printf("\n\n     0. Programatik irten");
       printf("\n =============================\n");

       do
       {
           printf(" Zure aukera: ");
           scanf("%d", &iAukera);
       } while ((iAukera < 0) || (iAukera > 4));

       printf("\n");

       switch(iAukera)
       {
           case 1:
               printf("\n Adelaide");
               printf("\n Koordenatuak: (%.6f, %.6f)", LAT_A, LON_A);
               printf("\n Hego hemisferioko ekialdea");
               break;
           case 2:
               printf("\n Brasilia");
               printf("\n Koordenatuak: (%.6f, %.6f)", LAT_B, LON_B);
               printf("\n Hego hemisferioko mendebaldea");
               break;
           case 3:
               printf("\n Calgary");
               printf("\n Koordenatuak: (%.6f, %.6f)", LAT_C, LON_C);
               printf("\n Ipar hemisferioko mendebaldea");
               break;
           case 4:
               printf("\n Donetsk");
               printf("\n Koordenatuak: (%.6f, %.6f)", LAT_D, LON_D);
               printf("\n Ipar hemisferioko ekialdea");
               break;
           default:
               printf("\n Irtetera goaz.");
       }  // switch

       if (iAukera != 0)
       {
           printf("\n\n Edozein tekla sakatu aurrera egiteko...");
           getch();   // pantailaratutako informazioa ikusi ahal izateko
       }
   } while (iAukera != 0);

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



Programa honek ere goiko algoritmoa aplikatzen du:

/* Ariketa-36b_MenuBat: hainbat aukeren menu bat */

// Programa hau 'Ariketa-18_MenuBat' programaren antzekoa da,
// harekiko dituen hobekuntzak:
//    1. Aldagai aukeratzailea char datu-motakoa da
//    2. Aldagai aukeratzailea irakurtzean egokitasuna kontrolatzen da
//    3. Iterazio bakoitzean pantaila garbitzen da
//    4. Menuak irteteko aukera du

#include <stdio.h>
#include <stdlib.h>   // system() funtziorako
#include <conio.h>    // getche() eta getch() funtzioetarako

int main()
{
   char cAukera;
   float fEragigai1, fEragigai2;

   do
   {
       system("cls");
       printf("\n");
       printf("\n ============Menua============");
       printf("\n   +   Batura lortzeko");
       printf("\n   -   Kendura lortzeko");
       printf("\n   *   Biderkadura lortzeko");
       printf("\n   /   Zatiketa burutzeko");
       printf("\n\n   A   Amaitu programa");
       printf("\n =============================");

       do
       {
           printf("\n Zure aukera: ");
           cAukera = getche() ;
           fflush(stdin) ;
       } while ((cAukera != '+') &&
                (cAukera != '-') &&
                (cAukera != '*') &&
                (cAukera != 'x') &&
                (cAukera != 'X') &&
                (cAukera != '/') &&
                (cAukera != 'A') && (cAukera != 'a'));

       printf("\n\n");

       switch(cAukera)
       {
           case '+':
               printf(" Zenbaki errealekin lan eginez, lehenengo batugaiaren balioa eman: ");
               scanf("%f", &fEragigai1);
               printf(" Zenbaki errealekin lan eginez, bigarren batugaiaren balioa eman:  ");
               scanf("%f", &fEragigai2);
               printf(" %.2f + %.2f = %.2f", fEragigai1, fEragigai2, fEragigai1+fEragigai2);
               break;
           case '-':
               printf(" Zenbaki errealekin lan eginez, kenkizunaaren balioa eman: ");
               scanf("%f", &fEragigai1);
               printf(" Zenbaki errealekin lan eginez, kentzailearen balioa eman: ");
               scanf("%f", &fEragigai2);
               printf(" %.2f - %.2f = %.2f", fEragigai1, fEragigai2, fEragigai1-fEragigai2);
               break;
           case '*':
           case 'x':
           case 'X':
               printf(" Zenbaki errealekin lan eginez, lehenengo biderkagaiaren balioa eman: ");
               scanf("%f", &fEragigai1);
               printf(" Zenbaki errealekin lan eginez, bigarren biderkagaiaren balioa eman:  ");
               scanf("%f", &fEragigai2);
               printf(" %.2f * %.2f = %.2f", fEragigai1, fEragigai2, fEragigai1*fEragigai2);
               break;
           case '/':
               printf(" Zenbaki errealekin lan eginez, zatikizunaren balioa eman:  ");
               scanf("%f", &fEragigai1);
               do
               {
                   printf(" Zenbaki errealekin lan eginez, zatitzailearen balioa eman: ");
                   scanf("%f", &fEragigai2);
               } while (fEragigai2 == 0.0);
               printf(" %.2f / %.2f = %.2f", fEragigai1, fEragigai2, fEragigai1/fEragigai2);
               break;
           default:
               printf("\n Amaitzera goaz.");
       }  // switch

       if ((cAukera != 'A') && (cAukera != 'a'))
       {
           printf("\n\n Edozein tekla sakatu aurrera egiteko...");
           getch();   // kalkuluaren emaitza ikusi ahal izateko
       }
   } while ((cAukera != 'A') && (cAukera != 'a'));

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






  • Ariketa-36a1_MenuBat.cbp | main.c       [aukeratzailea char]
  • Ariketa-36a2_MenuBat.cbp | main.c       [aukeratzailea int]
  • Ariketa-36b_MenuBat.cbp | main.c         [aukeratzailea char]


 

Ariketa 35 | Bi letren arteko distantzia

ZER DAKIDAN:
Orain arte garatu ditugun programetan ikusi dut programa batek algoritmo bat jarraitzen duela.



ZER IKASIKO DUDAN:
char datu-mota erabiliz, karaktere sorta baten minimoa nola zehazten den ikasiko dut. Algoritmo bera aplikatu beharko nuke zenbakiekin lan eginez gero.


A eta Z arteko letra maiuskula bat gure erreferentzia da. Prozesu errepikakor bat hasi eta teklatuaren bitartez letra bat irakurri, ereferentziaren eta irakurriko letraren arteko distantzia (zenbaki bat) kalkulatu balio minimoa gordez. Prozesu errepikakorretik irteteko erreferentzia den letra teklatuz irakurri. Programa amaitu aurretik pantailaratu letrarik hurbilena eta bere distantzia erreferentziarekiko.

Algoritmoa:
  1. Erreferentzia teklatutik irakurri, cErreferentzia aldagaiari balioa eman (jakinik letra maiuskula bat izan beharko dela)
  2. Hasieraketak. Bi izan daitezke, alde batetik distantzia minimoa gordeko duen iMinimoa zenbaki osoa (minimoa bilatzen ari garelako hasieran kopurua handi bat jarri beharko da); bigarren hasieraketa letrarik hurbilena gordetzeko cHurbilena aldagaia izango da, baina aurreko aldagaiarekin lotuta dagoenez bere hasieraketa ez da derrigorrezkoa
  3. Begiztaren iterazio bakoitzeko: cLetra aldagaiari balioa teklatuz eman, eta erreferentziarekiko iDistantzia aldagaiari distantzia kalkulatu ord funtzio estandarra aplikatuz, iDistantzia aldagaiaren balioa eta iMinimoa aldagaiaren balioa alderatu erabakiak hartzeko (emaitzak zehazteko, hots, minimoak zehazteko)
  4. Prozesu errepikakorretik irten cErreferentzia aldagaiaren balioa eta cLetra aldagaiaren balioa bat bera denean, baina kontuz, irtetean haien arteko diztantzia 0 izango da eta horrek minimoaren kalkuluarengan eragina du
  5. cLetra aldagaiaren balioa eta iMinimoa aldagaiaren balioa pantailaratu

Programa honek goiko algoritmoa aplikatzen du:

/* Ariketa-35_BiLetrenArtekoDistantzia: minimoaren algoritmoa */

// Programa honetan minimoaren algoritmoa garatzen da.
// Berezitasun bezala, ikus daiteke bi karakteren arteko kenketa
// egin daitekeela: iDistantzia = fabs(cErreferentzia - cLetra);

#include <stdio.h>
#include <conio.h>    // getche() funtziorako
#include <math.h>     // fabs() funtziorako

int main()
{
    char cErreferentzia, cLetra, cHurbilena;
    int iDistantzia, iMinimoa;

    printf("\n");

    do
    {
        printf("\n Erreferentzia izango den A..Z alfabetoko letra eman: ");
        cErreferentzia = getche();
        if ((cErreferentzia < 'A') || (cErreferentzia > 'Z'))
            printf("\n Datua larrien alfabetoko letra bat izan dadila! ");
    } while ((cErreferentzia < 'A') || (cErreferentzia > 'Z'));

    printf("\n\n Orain prozesu errepikakor batean sartuko gara, begizta edo itzuli bakoitzean");
    printf("\n letra majuskula bat sartuz eta erreferentziarekiko distantzia kalkulatuz.\n");

    iMinimoa = (int)('Z') - (int)('A') + 1 ;   // alfabetoaren maximoa baino 1 gehiago
    cHurbilena = cErreferentzia ;              // hasieraketa hau ez da derrigorrezkoa
    do
    {
        do
        {
            printf("\n A..Z alfabetoko letra eman (bukatzeko %c eman): ", cErreferentzia);
            cLetra = getche();
        } while ((cLetra < 'A') || (cLetra > 'Z'));
        if (cLetra != cErreferentzia)
        {
            iDistantzia = fabs((int)cErreferentzia - (int)cLetra);
            printf("\n '%c' eta '%c' arteko aldea %d da", cLetra, cErreferentzia, iDistantzia);
            if (iDistantzia < iMinimoa)
            {
                cHurbilena = cLetra;
                iMinimoa = iDistantzia;
            }
        }
    } while (cLetra != cErreferentzia);

    printf("\n Letrarik hurbilena: %c", cHurbilena);
    printf("\n '%c' eta '%c' arteko aldea %d da", cHurbilena, cErreferentzia, iMinimoa);

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






  • Ariketa-35_BiLetrenArtekoDistantzia.cbp | main.c  


 

Ariketa 34 | Zesar zifratze-sistema

ZER DAKIDAN:
Karaktereen char datu-mota ezagutzen dut eta karaktereak ASCII taularen arabera sailkatzen direla dakit.



ZER IKASIKO DUDAN:
char datu-motako aldagai bat teklatuz irakurri ondoren, Zesar zifratze-metodoa erabiliz karaktere zifratua nola lor daitekeen ikasiko dut.

Kriptografian, Zesarren zifratze-sistema (edo Zesar zifratzea) mezuak enkriptatzeko teknikarik zaharrenetarikoa da, baita erabilienetako bat ere. Metodo honek Julio Zesar ospetsuaren ohorean dauka izena, zeinek bere jeneralekin komunikatzeko erabiltzen zuen.

Ordezkatze-metodo bat da, non hasierako mezuaren letra bakoitza beste letra batengatik ordezkatzen den: Alfabetoan 3 posizio aurrerago dagoen letrarengatik. Horrela, A letra D letra bihurtuko litzateke, B-a E etab.




Programa honek Zesar zifratzea delako enkriptazio teknika erakusten du, alfabeto larrien letra bat eman eta programak bere karaktere zifratua erakutsiko du (ASCII taulako 3 posizio aurrerago dagoena). Adibidez, A sartzean emaitza D izango da, B sartzean emaitza E izango da, X sartzean emaitza A izango da, Y sartzean emaitza B izango da eta Z sartzean emaitza C izango da:

Zesar zifratzea programaren lehen bertsioan switch agindu bat erabiltzen da datua den alfabeto larrien letra zifratzeko:

/* Ariketa-34a_ZesarZifratzeSistema: Zesarren zifratze-sistema */

// Zesar zifratze-teknikan letra bakoitzaren desplazamendua 3 da. Karaktere bat
// sartu eta switch agindu bati esker bere karaktere desplazatua lortuko da.

#include <stdio.h>
#define iDESPLAZAMENDUA 3

int main()
{
    char cDatua;
    char cEmaitza;

    printf("\n");
    do
    {
        printf("Zifratu nahi den karakterea sartu (A eta Z artekoa): ");
        scanf("%c", &cDatua);
        fflush(stdin);
    } while (cDatua < 'A' || cDatua > 'Z');

    switch(cDatua)
    {
     case 'Z': cEmaitza = 'C';
               break;
     case 'Y': cEmaitza = 'B';
               break;
     case 'X': cEmaitza = 'A';
               break;
     default:  // sartzen da cDatua ez denean: X, Y edo Z
               cEmaitza = cDatua + iDESPLAZAMENDUA;
    }
    printf("\t%c >>> %c\n", cDatua, cEmaitza);

    return 0;
}




Alfabeto larrien letra bat zifratzeko datuari +3 egingo zaio. Alfabetoaren zerrenda zirkular bat osatuko da, zerrendaren oinarria A karakterea da eta alfabetoak 26 letra dituenez zatiketa osoaren hondarraz lortzen dira karaktereen emaitza zifratuak.

Zesar zifratzea programaren bigarren bertsioan A-Z alfabetoaren zerrenda zirkular bat osatuko da:

/* Ariketa-34b_ZesarZifratzeSistema: Zesarren zifratze-sistema */

// Zesar zifratze-teknikan letra bakoitzaren desplazamendua 3 da. Baina
// programa honek desplazamenduaren neurria hautatzeko aukera ematen du.
// Alfabetoaren zerrenda zirkular bat osatuz, desplazamendua finkatu eta
// datua den letra bati dagokion karaktere desplazatua lortuko da.

#include <stdio.h>

int main()
{
    char cDatua;
    char cEmaitza;
    int iDesplazamendua;

    printf("\n");
    printf("         1         2     2\n");
    printf("12345678901234567890123456\n");
    printf("ABCDEFGHIJKLMNOPQRSTUVWXYZ    26 karaktere\n\n");

    do
    {
        printf("Zifratu nahi den karakterea sartu (A eta Z artekoa): ");
        scanf("%c", &cDatua);
        fflush(stdin);
    } while (cDatua < 'A' || cDatua > 'Z');

    printf("Enkriptatze-gakoa sartu (kopuru oso bat): ");
    scanf("%d", &iDesplazamendua);
    if (iDesplazamendua < 0)  // gako negatiboa bada positibo jarri
        iDesplazamendua = iDesplazamendua * (-1);

    cEmaitza = (cDatua - 'A' + iDesplazamendua) % 26 + 'A';
    printf("\t%c >>> %c\n", cDatua, cEmaitza);

    return 0;
}

Argi dago azken programa hau aurrekoa baino ahaltsuagoa dela. Izan ere, desplazamendua beti 3 izan beharrean teklatuz irakurtzen den balio bat baita. Aurrerago erakutsiko den Ariketa 49 | Zesar zifratze-sistema artikuluan mezu osoak enkriptatzen eta desenkriptatzen ikasiko dugu.







  • Ariketa-34a_ZesarZifratzeSistema.cbp | main.c  
  • Ariketa-34b_ZesarZifratzeSistema.cbp | main.c  


 

ASCII taula, bigarren hurbilketa

ZER DAKIDAN:
Karaktereen char datu-mota ezagutzen dut eta karaktereak ASCII taularen arabera sailkatzen direla dakit.



ZER IKASIKO DUDAN:
char datu-motako aldagai bat erabiliz, ASCII taula aztertuko dut ikasteko karaktereak nola antolatzen diren taularen barruan, labur esanda:
  1. Kontroleko karaktereak
  2. Digituak
  3. Letra larriak
  4. Letra xeheak

Dakigunez, karaktereak adierazteko karaktere bakoitzari zenbaki bat esleitzen zaio, eta horrela osatzen da American Standard Code for Information Interchange taula, ASCII taula. ASCII taula ordenaturik dago eta 256 elementuz osaturik dago (256 karaktere: byte batek ematen dituen 28=256 kodeak).

ASCII taularen lehen erdiari ASCII taula estandarra esaten zaio, taula estandarrak 128 karaktere biltzen ditu (0 kodean hasita eta 127 kodean bukatuta), ASCII taula estandarrak letra eta sinbolo arruntenak biltzen ditu eta 7 bit behar dira denak adierazi ahal izateko (27=128). Jarraian erakusten den ASCII taula estandar honetan karaktereen bit segidak ikus daitezke eta horiekin batera karaktere bakoitzaren posizioa sistema hamartarrean eta hexadezimalean (hamaseitarrean):

ASCII taula handiago ikusteko bere gainean klik egin

ASCII taularen lehen erdiari ASCII taula estandarra esaten bazaio, ASCII taularen bigarren erdiari ASCII taula luzatua (edo hedatua) esaten zaio. Taula hedatuak ere 128 karaktere biltzen ditu (128 kodean hasita eta 255 kodean bukatuta), ASCII taula hedatuak karaktere bereziak eta karaktere grafikoak biltzen ditu. Gogoratu ASCII taula hedatuan hiru azpizati bereizten direla:

  1. Kontrol-karaktereak: 0 posiziotik 31ra dauden karaktereak gehi 127 posizioko karakterea
  2. Karaktere inprimagarriak: 32tik 126 dauden karaktereak
  3. Karaktere bereziak: 128 posiziotik 255 posiziora dauden karaktereak

Hona hemen ASCII taula hedatua, gehiago jakiteko artikulu hau irakurri:

ASCII taula handiago ikusteko irudiaren gainean klik egin



ASCII-zatia_1a programa honek ASCII taularen zati bat erakusten du. ASCII taulako aurreneko karaktereak kontrol karaktereak dira eta horregatik, gure programan 32 kodea duen karakterearekin hasi eta 255 kodea duen karakterearekin bukatu dugu. Karaktereak pantailan aurkezterakoan, hamarnaka hartu dira.

Horrela, karaktere jakin bati dagokion kodea ezagutzeko, W karakterea adibidez, bere lerroko zenbakia hartuko dugu 8 eta bere zutabeko zenbakia 7, eta biak konposatuz 87 lortuko dugu, W karaktereari dagokion ASCII kodea. Ikusten denez, kontrol-karakterea den 127 posiziokoak bere aurreko zuriunea ezabatu du:


Programaren funtsa taula bat idaztea da eta horretarako for agindu bat beste for agindu batean garatuko da. Honela:

...
// ASCII karaktereak inprimatu
cLetra = 40;  // edo cLetra = '(';   edo cLetra = '\x28';
for (iLerroa = 4; iLerroa <= 25; iLerroa++)
{
    printf("%3d   ", iLerroa);
    for (iZutabea = 1; iZutabea <= 10; iZutabea++)
    {
        printf("  %c", cLetra);
        cLetra++;
    }
    printf("\n");  // hurrengo errenkadan idazteko 
}
...

Erreparatu barruko for bitartez errenkada bat idatzi ondoren, hurrengo errenkada idatzi behar dela eta horretarako printf("\n") agindu bat behar da. Lehen errenkada modu berezian pantailaratu da 30 posizioko eta 31 posizioko karaktereak kontrol-karaktereak direlako.

Gorago aipatu den bezala, karaktere inprimagarrien ASCII-zatia_1a programaren kodea hemen erakusten da:

/* ASCII-zatia_1a: ASCII taula, karaktere inprimagarriak */

// Lehen karakterea 30. posiziokoa hamartarrean eta '\x1e'
// hexadezimal sisteman. Taula 10 zutabekoa, (1etik 10era
// eta 23 errenkada (3tik 25era). Beraz, azken karaktereak
// 250+0, 250+1, 250+2, 250+3, 250+4, 250+5, ... 250+9.

#include <stdio.h>

int main()
{
    char cLetra;
    int iLerroa, iZutabea;

    printf("\n");

    // zutabe buruak inprimatu
    printf("      ");
    for (iZutabea = 0; iZutabea <= 9; iZutabea++)
    {
        printf("%3d", iZutabea);
    }
    printf("\n");

    // azpimarra lerroa inprimatu
    printf(" ======");
    for (iZutabea = 1; iZutabea <= 10; iZutabea++)
    {
        printf("===");
    }
    printf("\n");

    // ASCII karaktereak inprimagarriak pantailaratu
    printf("%4d  %3c%3c", 3, '\xfe', '\xfe');  // lehen bi laukitxoak
    cLetra = 32;  // edo cLetra = ' ';  edo cLetra = '\x20';
    for (iZutabea = 3; iZutabea <= 10; iZutabea++)
    {
        printf("  %c", cLetra);
        cLetra++;
    }
    printf("\n");  // hurrengo errenkadan idazteko
    for (iLerroa = 4; iLerroa <= 25; iLerroa++)
    {
        printf("%4d  ", iLerroa);
        for (iZutabea = 1; iZutabea <= 10; iZutabea++)
        {
            printf("  %c", cLetra);
            cLetra++;
        }
        printf("\n");  // hurrengo errenkadan idazteko
    }

    // azken azpimarra lerroa inprimatu
    printf(" ======");
    for (iZutabea = 1; iZutabea <= 10; iZutabea++)
    {
        printf("===");
    }
    printf("\n");
    getchar();
    return 0;
}


0 posiziotik 31ra dauden karaktereak gehi 127 posizioko karakterea, ASCII-zatia_1b programan ASCII taularen hasierako 60 karaktereak pantailaratzen dira, horietarik lehenak ez inprimagarriak eta hurrengoak inprimagarriak. Kodea hemen erakusten da:

/* ASCII-zatia_1b: ASCII taula, karaktere ez inprimagarriak */

// Lehen karakterea 0. posiziokoa hamartarrean eta '\x00'
// hexadezimal sisteman. Taula 10 zutabekoa, (1etik 10era
// eta 6 errenkada (0tik 5era). Beraz, azken karaktereak
// 50+0, 50+1, 50+2, 50+3, 50+4, 50+5, 50+6, ... 50+9.

// Inprimagarriak 32tik (espazioa) 59ra (puntu eta koma).
// 0tik 31ra ez inprimagarriak izan arren eragina dute.

#include <stdio.h>

int main()
{
    char cLetra;
    int iLerroa, iZutabea;

    printf("\n");

    // zutabe buruak inprimatu
    printf("      ");
    for (iZutabea = 0; iZutabea <= 9; iZutabea++)
    {
        printf("%3d", iZutabea);
    }
    printf("\n");

    // azpimarra lerroa inprimatu
    printf(" _____");
    for (iZutabea = 1; iZutabea <= 10; iZutabea++)
    {
        printf("___");
    }
    printf("_");
    printf("\n\n");

    // ASCII karaktereak ez inprimagarriak pantailaratu
    cLetra = '\x00';  // edo cLetra = 0;  (0 posizioko karakterea)
    for (iLerroa = 0; iLerroa <= 5; iLerroa++)
    {
        printf("%3d   ", iLerroa);
        for (iZutabea = 1; iZutabea <= 10; iZutabea++)
        {
            printf("  %c", cLetra);
            cLetra++;
        }
        printf("\n");  // hurrengo errenkadan idazteko
    }

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

ASCII-zatia_1b programa exekutatzean inprimagarriak ez diren karaktereak ez dira pantailan ikusiko baina haien eragina nabaritzen da, adibidez 7 posizioko karakterea pantailaratzean bere soinua entzun daiteke edo 11 posizioko tabuladore bertikala. Noski, 32 posiziotik aurrerako karaktereak inprimagarriak dira (32 posiziokoa zuriunea da eta ez da ikusten, baina hori da, hain zuzen ere, bere kasuan ikusi beharko litzatekeena).



Hiru programa hauek linealak dira:

  • ASCII-zatia_2, ASCII taula estandarra erakusten duena
  • ASCII-zatia_3, letra larriak erakusten dituena
  • ASCII-zatia_4, 0-tik 9-ra hamar digituak erakusten dituena
/* ASCII-zatia_4: zifrak */

#include <stdio.h>

int main()
{
    char cLetra;
    int iKontagailu;

    printf("\n");

    printf("  Kodea        Karakterea\n");
    printf("  -----        ----------\n");

    cLetra = 0;
    for (iKontagailu = 0; iKontagailu <= 127; iKontagailu++)
    {
        printf("%7d -----> |%c|\n", iKontagailu, cLetra);
        cLetra++;
    }

    printf("  -----        ----------\n");
    printf("  Kodea        Karakterea\n");

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






  • ASCII-zatia_1a.cbp | main.c  
  • ASCII-zatia_1b.cbp | main.c  
  • ASCII-zatia_2.cbp | main.c  
  • ASCII-zatia_3.cbp | main.c  
  • ASCII-zatia_4.cbp | main.c    


 

ASCII taula

ZER DAKIDAN:
Karaktereen char datu-mota ezagutzen dut eta karaktereak ASCII taularen arabera sailkatzen direla dakit. Aldagai batea balioak aldagaiaren datu-motako muga gainditzeari gainezkatze edo "overflow" esaten zaio



ZER IKASIKO DUDAN:
char datu-motako aldagai bat erabiliz, gainezkatze bat eragingo dut, gauza bera egingo dut unsigned char datu-motako aldagai bat erabiliz.

Karaktereak adierazteko karaktere bakoitzari zenbaki bat esleitzen zaio, eta horrela osatzen da American Standard Code for Information Interchange taula, ASCII taula. ASCII taula ordenaturik dago eta 256 elementuz osaturik dago (256 karaktere: byte batek ematen dituen 28=256 kodeak).

ASCII taularen lehen erdiari ASCII taula estandarra esaten zaio, taula estandarrak 128 karaktere biltzen ditu (0 kodean hasita eta 127 kodean bukatuta). ASCII taula estandarrak letra eta sinbolo arruntenak biltzen ditu eta 7 bit behar dira denak adierazi ahal izateko (27=128).

ASCII taularen bigarren erdiari ASCII taula luzatua (edo hedatua) esaten zaio, taula hedatuak ere 128 karaktere biltzen ditu (128 kodean hasita eta 255 kodean bukatuta). ASCII taula hedatuak karaktere bereziak eta karaktere grafikoak biltzen ditu.

ASCII taula hedatuan hiru azpizati bereizten diren:

  1. Kontrol-karaktereak: 0 posiziotik 31ra dauden karaktereak gehi 127 posizioko karakterea
  2. Karaktere inprimagarriak: 32tik 126 dauden karaktereak
  3. Karaktere bereziak: 128 posiziotik 255 posiziora dauden karaktereak

Hona hemen ASCII taula hedatua, gehiago jakiteko artikulu hau irakurri:

ASCII taula handiago ikusteko irudiaren gainean klik egin

Jarraian erakusten den ASCII taula estandar honetan karaktereen bit segidak ikus daitezke eta horiekin batera karaktere bakoitzaren posizioa sistema hamartarrean eta hexadezimalean (hamaseitarrean):

ASCII taula handiago ikusteko bere gainean klik egin




ASCII-Taula_1 delako programa honek ASCII taula hedatua erakusten du karaktereak hogeika pantailaratuz. Datu-moten informazio hau gogora ekarriz, jakina da char datu-motak 1 byte hartzen duela memorian eta bere heina -128tik +127ra doala (edo +0tik +255era doala unsigned char bezala deklaratuko balitz).

ASCII-Taula_1 programaren aldagaiak hiru dira, eta bakoitzaren zeregina jarraian azaltzen da:

  • cKarak, ASCII taula hedatuaren karaktereak eta haien kodeak erakusteko, bere datu mota char denez dagokion heina -128tik +127ra doa (gogoratu signed char ≡ char)
  • iKont, kontagailu bat begizta infinitoaren iterazioak zenbatzeko eta karaktereak hogeiko taldetan pantailaratzeko
  • cIrteteko, begizta infinitoa eteteko

ASCII-Taula_1 programa exekutatzean ondoko hau ikus daiteke; non gainezkatzea (edo "overflow" efektua) honela ulertu behar den:
                                            Bi biten arteko batuketa
                                            ========================
   127 kodeko karakterea    0111 1111      Unitateak: 1+1=0 (eta 1 bururako, hamarrekoetan)
   1 bit gehituz            0000 0001      Hamarrekoak: 1+0+1[bururakoa]=0 (eta 1 bururako)
                         ---------------   Ehunekoak: 1+0+1[bururakoa]=0 (eta 1 bururako)
  -128 kodeko karakterea    1000 0000   (Ç karakterea)
127 kodea duen karaktereari +1 egitean gainezkatzea gertatzen da eta 'Ç' ematen du
                                            Bi biten arteko batuketa
                                            ========================
  -1 kodeko karakterea      1111 1111      Unitateak: 1+1=0 (eta 1 bururako, hamarrekoetan)
   1 bit gehituz            0000 0001      Hamarrekoak: 1+0+1[bururakoa]=0 (eta 1 bururako)
                         ---------------   Ehunekoak: 1+0+1[bururakoa]=0 (eta 1 bururako)
   0 kodeko karakterea      0000 0000   (0 posizioko karakterea)
-1 kodea duen karaktereari +1 egitean gainezkatzea gertatzen da eta '\x00' karakterea ematen du

Hauxe da ASCII-Taula-1 programaren kodea:

/* ASCII-Taula_1: signed char [-128..+127] (edo char ) */

// Ikusi ere 'ASCII-Taula_2' projektua non ucKarak aldagaia
// honela definitu den:  unsigned char [+0..+255]

#include <stdio.h>

int main()
{
    char cKarak;
    int iKont = 1;
    char cIrteteko;

    printf("\n");
    printf("            Kodea     Karakterea       Kontagailua\n");
    printf("            =====     ==========       ===========\n");
    for (cKarak = -128; cKarak <= 127; cKarak++)
    {
        printf("%15d           %c              iKont=%d\n", (int)cKarak, cKarak, iKont-1);
        if (iKont % 20 == 0)
        {
            printf("\nINTRO sakatu aurrera egiteko");
            printf("\nAmaitzeko ZURIUNEA+INTRO...  ");
            cIrteteko = getchar();
            printf("\n");
            if (cIrteteko == ' ')
                return 0;
            else
            {
                printf("            Kodea     Karakterea       Kontagailua\n");
                printf("            =====     ==========       ===========\n");
            }
        }
        iKont++;
    }
}

ASCII-Taula_2 delako programa ASCII-Taula_1 bezalakoa da, duen alde bakarra ucKarak aldagaian datza, zein unsigned char bezala deklaratu den (bere heina +0tik +255era doa).

Aurrekoaren bezala ASCII-Taula_2 programaren aldagaiak hiru dira, eta bakoitzaren zeregina ezaguna da:

  • ucKarak, ASCII taula hedatuaren karaktereak eta haien kodeak erakusteko, bere datu mota unsigned char denez dagokion heina +0tik +225era doa
  • iKont, kontagailu bat begizta infinitoaren iterazioak zenbatzeko eta karaktereak hogeiko taldetan pantailaratzeko
  • cIrteteko, begizta infinitoa eteteko

ASCII-Taula_2 programa exekutatzean ondoko gainezkatzea gertatzen da:

                                            Bi biten arteko batuketa
                                            ========================
   255 kodeko karakterea    1111 1111      Unitateak: 1+1=0 (eta 1 bururako, hamarrekoetan)
   1 bit gehituz            0000 0001      Hamarrekoak: 1+0+1[bururakoa]=0 (eta 1 bururako)
                         ---------------   Ehunekoak: 1+0+1[bururakoa]=0 (eta 1 bururako)
   0 kodeko karakterea      0000 0000   (0 posizioko karakterea)

Hauxe da ASCII-Taula-2 programaren kodea:

/* ASCII-Taula_2: unsigned char [+0..+255] */

// Ikusi ere 'ASCII-Taula_1' projektua non cKarak aldagaia
// honela definitu den:  char edo signed char [-128..+127]

#include <stdio.h>

int main()
{
    unsigned char ucKarak;
    int iKont = 1;
    char cIrteteko;

    printf("\n");
    printf("            Kodea     Karakterea       Kontagailua\n");
    printf("            =====     ==========       ===========\n");
    for (ucKarak = 0; ucKarak <= 255; ucKarak++)
    {
        printf("%15d           %c              iKont=%d\n", (int)ucKarak, ucKarak, iKont-1);
        if (iKont % 20 == 0)
        {
            printf("\nINTRO sakatu aurrera egiteko");
            printf("\nAmaitzeko ZURIUNEA+INTRO...  ");
            cIrteteko = getchar();
            printf("\n");
            if (cIrteteko == ' ')
                return 0;
            else
            {
                printf("            Kodea     Karakterea       Kontagailua\n");
                printf("            =====     ==========       ===========\n");
            }
        }
        iKont++;
    }
}


Aspaldiko Datu-moten taula artikulua gogora ekarriz, char datu-mota eta unsigned char datu-mota alderatzen dira ASCII-Taula_3 programa honetan:


/* ASCII-Taula_3: char eta unsigned char */

#include <stdio.h>
#include <limits.h>

int main()
{
    char cLetra;
    int iKontagailu1;
    unsigned char ucLetra;
    int iKontagailu2;

    printf("-------------------------------------------------------------");
    printf("\n     'limits.h' fitxategian definitutako konstante osoak:");
    printf("\n              - CHAR_MIN  = %d", CHAR_MIN);
    printf("\n              - CHAR_MAX  =  %d", CHAR_MAX);
    printf("\n              - UCHAR_MIN =  (definitu gabe, 0 litzateke)");
    printf("\n              - UCHAR_MAX =  %d", UCHAR_MAX);

    printf("\n             sizeof(char) = %d byte [-128..127]", (int)sizeof(char));
    printf("\n    sizeof(unsigned char) = %d byte    [0..255]", (int)sizeof(unsigned char));
    printf("\n-------------------------------------------------------------");
    printf("\n\n");

    printf("  Kodea Karakterea        Kodea Karakterea\n");
    printf("  ===== ==========        ===== ==========\n");

    ucLetra = -128;
    cLetra = 0;
    iKontagailu2 = 0;
    for (iKontagailu1 = -128; iKontagailu1 <= 127; iKontagailu1++)
    {
        printf("%7d -----> |%c|\t", iKontagailu1, ucLetra);
        printf("%7d -----> |%c|\n", iKontagailu2, cLetra);
        ucLetra++;
        cLetra++;
        iKontagailu2++;
    }

    printf("  ===== ==========        ===== ==========\n");
    printf("  Kodea Karakterea        Kodea Karakterea\n\n");

    getchar();
    return 0;
}






  • ASCII-Taula_1.cbp | main.c  
  • ASCII-Taula_2.cbp | main.c   
  • ASCII-Taula_3.cbp | main.c  


 

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 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;
}
 

Karaktereak maneiatzeko funtzioak: putchar(), getchar(), getch() eta getche()

Karaktere bat irakurtzeko orokorra den scanf() funtzioaren bitartez egin daiteke. Karaktere bat irakurtzeko espezifikoak diren lau funtzio hauek ikasiko ditugu: getchar(), getch() eta getche().  


int getchar(void);
int putchar(int c);

getchar() funtzioak ENTER sakatzean teklatutik irakurritako karaktere bat irakurri eta ASCII balioa itzultzen du, EOF itzultzen du CRTL+Z sakatzean.

/* GETCHAR_funtzioa.cbp */

// getchar() funtzioak zenbaki oso bat itzultzen du, karakterearen ASCII balioa

#include <stdio.h>

int main()
{
   char cLetra;

   printf("\n\n Letra minuskulak irakurtzen...");
   printf("\n");
   do
   {
       printf("\n Alfabetoko letra bat eman ('a' eta 'z' artekoa). Amaitzeko 'X' sartu: ");
       cLetra=getchar();
       fflush(stdin);   // teklatuaren bufferra garbitzeko Windows sistemetan
       printf(" Jasotako karakterea: |%c| \n", cLetra);
   }
   while (cLetra != 'X');

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

putchar() funtzioak idatzitako karakterea itzultzen du. Idazketa-errore bat gertatzen bada, putchar()-ek EOF itzultzen du.

/* PUTCHAR_funtzioa.cbp */

// putchar() funtzioak idatzitako karakterea itzultzen du

#include <stdio.h>

int main()
{
   int iKont;
   char cKont;

   printf("\n\n Larrien alfabetoa pantailaratzen...");
   printf("\n");

   for (iKont=65; iKont<=90; iKont++)
   {
       putchar(' ');   // zuriunea, karaktereak banatzeko
       putchar(iKont);
   }

   printf("\n\n Xeheen alfabetoa pantailaratzen...");
   printf("\n");

   for (cKont='a'; cKont<='z'; cKont++)
   {
       putchar(' ');   // zuriunea, karaktereak banatzeko
       putchar(cKont);
   }

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



int getch(void);

Parametroak: funtzio honek ez du parametrorik onartzen.
Itzulera-balioa: funtzio honek tekla presionatuaren ASCII balioa itzultzen du.

getch() funtzio ez-estandarra da, eta conio.h fitxategian dago. Beste funtzio batzuk bezala, getch()-k teklatuaren karaktere bakarra irakurtzen du. Baina ez du bufferrik erabiltzen, eta, beraz, sartutako karakterea berehala itzultzen da, ENTER tekla sakatu arte itxaron gabe.

getch() funtzioari buruzko puntu garrantzitsuak:

  1. getch() funtzioak irteerako kontsola geldiarazten du tekla bat sakatu arte.
  2. Ez du bufferrik erabiltzen sarrera-karakterea gordetzeko.
  3. Sartutako karakterea berehala itzultzen da ENTER teklaren zain egon gabe.
  4. Sartutako karakterea ez da kontsolan agertzen.
  5. getch() funtzioa ezkutuko sarrerak onartzeko erabil daiteke, hala nola pasahitzak, kutxazain automatikoen PIN zenbakiak, etab.
/* GETCH_funtzioa.cbp */

// getch() funtzioak zenbaki oso bat itzultzen du, karakterearen ASCII balioa

#include <stdio.h>
#include <conio.h>   // getch() funtzioarako

int main()
{
   char cLetra;

   printf("\n\n Letra minuskulak irakurtzen...");
   printf("\n");
   printf("\n Alfabetoko letra bat eman ('a' eta 'z' artekoa). Amaitzeko 'X' sartu:\n ");
   do
   {
       cLetra=getch();
       // fflush(stdin);   ez da teklatuaren bufferra garbitu beharrik
       printf("Jasotako karakterea: |%c|\n ", cLetra);
   }
   while (cLetra != 'X');

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



int getche(void);

getche() teklatuaren karaktere bakarra irakurtzen du eta berehala agertzen da irteera-pantailan, ENTER teklaren zain egon gabe. Funtzio hau, getch() bezala, ez da estandarra eta conio.h fitxategian dago.

/* GETCHE_funtzioa.cbp */

// getche() funtzioak zenbaki oso bat itzultzen du, karakterearen ASCII balioa

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

int main()
{
   char cLetra;

   printf("\n\n Letra minuskulak irakurtzen...");
   printf("\n");
   do
   {
       printf("\n Alfabetoko letra bat eman ('a' eta 'z' artekoa). Amaitzeko 'X' sartu: ");
       cLetra=getche();
       // fflush(stdin);   ez da teklatuaren bufferra garbitu beharrik
       printf("\n Jasotako karakterea: |%c|", cLetra);
   }
   while (cLetra != 'X');

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