teorikopraktiko etiketadun mezuak erakusten. Erakutsi mezu guztiak
teorikopraktiko etiketadun mezuak erakusten. Erakutsi mezu guztiak

2025(e)ko apirilaren 9(a), asteazkena

Ariketa 74 | Koloreak

ZER DAKIDAN:
Informazioa pantailan idazteko printf() funtzioa ezagutzen dut.



ZER IKASIKO DUDAN:
Informazioa koloretan pantailaratzen ikasiko dut SetConsoleTextAttribute() funtzioa erabiliz.

Ariketa 66 | Koloreak artilukuan ikusi zen kontsolan testu bat idaztean bere kolorea eta atributuak aukera daitezkeela. Artikulu honetan helburu bera beteko da, baina ANSI ihes-sekuentziak erabili ordez SetConsoleTextAttribute() funtzioari esker lortuko da. Kontsolako SetConsoleTextAttribute() funtzioa Windows© sistemetan soilik erabil daiteke.

Kolore bakoitzari zenbaki bat dagokio, baina erabilterrazago egitearren hitzezko konstante esanguratsuak defini daitezke, honela adibidez:

            #define BELTZA  0
            #define URDINA  1            // itsas urdina
            #define BERDEA  2
            #define ZYANA   3
            #define GORRIA  4
            #define MAGENTA 5            // morea
            #define HORIA   6            // urre kolorea
            #define ZURIA   7            // gris argia 
            #define BELTZ_DISTIRA    8   // gris iluna
            #define URDIN_DISTIRA    9
            #define BERDE_DISTIRA   10
            #define ZYAN_DISTIRA    11
            #define GORRI_DISTIRA   12
            #define MAGENTA_DISTIRA 13
            #define HORI_DISTIRA    14   // horia
            #define ZURI_DISTIRA    15   // zuri-zuria

Koloreak kontsolan 8 bitekin adierazten dira. Testu baten letrak eta testuaren hondoa aukera daitezke eta SetConsoleTextAttribute() funtzioari adierazi ahal zaio testua eta hondoa kolore desberdinez agerraztea, testurako 4 bit erabiltzen dira eta hondorako beste lau bit. Sintaxia holako zerbait izan daiteke:

SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), iKolorea)

Non STD_OUTPUT_HANDLE ohiko kontsola izendatzen duen konstantea den eta iKolorea parametroa idazketaren kolorea den. Nahiz eta iKolorea parametroa bakarra izan, gorago aipatu den bezala, testuaren kolorea eta hondoaren kolorea zehatz daitezke. Hona hemen adibide bat:

       iKolorea = HORIA | URDINA << 4;   // koloreak lotzen dira:
                                         // testua HORIA (lehen 4 bitak) eta 
                                         // hondoa URDINA (hurrengo 4 bitak)
       SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), iKolorea);

Aurreko aginduak bete ondoren, hurrengo printf() funtzioen testuak kolore hori eta hondo urdin batean agertuko da. Ohiko koloretara itzultzeko (testua zuriz eta hondoa beltzez) agindua hau delarik:

       iKolorea = ZURIA;   // hondoa ez da adierazten
       SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), iKolorea);

Esate baterako, demagun hurrengo testuak agertu nahi ditugula pantailan:

Hauxe litzateke goiko irudiko testuak agerrarazteko kode zatia:

/* Ariketa-74_Koloreak: proiektuaren kodearen zati bat. */

    ...
    // Testua eta atzeko planoaren koloreak definitzeko
    int iTestuKolorea;
    int iHondoKolorea;
    int iKolorea;

    // LEHEN MEZUAREN IDAZKETA PRESTATU ETA IDATZI
    // Koloreak ezarri
    iTestuKolorea = MAGENTA_DISTIRA;  // More argia (testuaren kolorea)
    iHondoKolorea = BERDEA;           // Berdea (hondoaren kolorea)
    iKolorea = iTestuKolorea | iHondoKolorea << 4;  // Koloreak lotzen dira:
                                                    // iTestuKolorea (lehen 4 bitak) eta
                                                    // iHondoKolorea (hurrengo 4 bitak)
    SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), iKolorea);
    // Testua inprimatu
    printf("   Testua MORE ARGIA eta hondoa BERDEA         \n");
    // Ohiko itxurako koloreak berreskuratu (testua zuriz eta atzeko planoa beltzez)
    SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), 7); // Ohiko kolorera itzuli

    // BIGARREN MEZUAREN IDAZKETA PRESTATU ETA IDATZI
    // Koloreak ezarri
    iTestuKolorea = URDINA;          // Itsas urdina (testuaren kolorea)
    iHondoKolorea = HORI_DISTIRA;    // Hori distiratsua (hondoaren kolorea)
    iKolorea = iTestuKolorea | iHondoKolorea << 4;   // Koloreak lotzen dira:
                                                     // iTestuKolorea (lehen 4 bitak) eta
                                                     // iHondoKolorea (hurrengo 4 bitak)
    SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), iKolorea);
    // Testua inprimatu
    printf("   Testua URDINA eta hondoa HORI DISTIRATSUA   \n");
    // Ohiko itxurako koloreak berreskuratu (testua zuriz eta atzeko planoa beltzez)
    SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), 7); // Ohiko kolorera itzuli

    // HIRUGARREN MEZUA IDATZI OHIKO KOLOREAK AUKERATURIK BAITAUDE
    printf("Testuaren ohiko kolorea...\n");
    ...


/* Ariketa-74_Koloreak: testuen koloreak SetConsoleTextAttribute() funtzioz. */


#include <stdio.h>
#include <windows.h>  // Windows-en koloreak aldatzeko funtzioak erabiltzeko

#define BELTZA  0
#define URDINA  1
#define BERDEA  2
#define ZYANA   3
#define GORRIA  4
#define MAGENTA 5
#define HORIA   6
#define ZURIA   7
#define BELTZ_DISTIRA    8
#define URDIN_DISTIRA    9
#define BERDE_DISTIRA   10
#define ZYAN_DISTIRA    11
#define GORRI_DISTIRA   12
#define MAGENTA_DISTIRA 13
#define HORI_DISTIRA    14
#define ZURI_DISTIRA    15


int HondoaAukeratu(void)
{
    int iKolorea;

    do
    {
        printf("===========================================\n");
        printf("                Koloreak\n");
        printf("===========================================\n");
        printf(" 0 BELTZA                  8 BELTZ ARGIA (gris iluna)\n");
        printf(" 1 URDINA (itsas urdina)   9 URDIN ARGIA\n");
        printf(" 2 BERDEA                 10 BERDE ARGIA\n");
        printf(" 3 ZYANA (urdin argia)    11 ZYAN ARGIA\n");
        printf(" 4 GORRIA                 12 GORRRI ARGIA\n");
        printf(" 5 MAGENTA (morea)        13 MAGENTA ARGIA\n");
        printf(" 6 HORIA (urre kolorea)   14 HORI ARGIA\n");
        printf(" 7 ZURIA (gris argia)     15 ZURI ARGIA (zuri-zuria)\n");
        printf("===========================================\n");
        printf(" Hondoa aukeratu: ");
        scanf("%d", &iKolorea);
    } while (iKolorea < 0 || iKolorea > 15);

    return iKolorea;
}


void TestuKoloreaEzarri(int iKolorea)
{
    SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), iKolorea);
}


int main()
{
    // Testua eta atzeko planoaren koloreak definitzeko
    int iTestuKolorea;
    int iHondoKolorea;
    int iKont;
    int iHondoa;

    // Koloreak ezarri
    iTestuKolorea = ZURIA;          // Zuria (testuaren kolorea)
    iHondoKolorea = GORRI_DISTIRA;  // Gorri distiratsua (hondoaren kolorea)
    TestuKoloreaEzarri(iTestuKolorea | iHondoKolorea << 4);  // Koloreak lotzen dira: iTestuKolorea (lehen 4 bitak) eta iHondoKolorea (hurrengo 4 bitak)
    // Testua inprimatu
    printf("  Testua ZURIA eta hondoa GORRI DISTIRATSUA                 \n");
    // Ohiko itxurako koloreak berreskuratu
    TestuKoloreaEzarri(7); // Kolore normalean (testua zuriz eta atzeko planoa beltzez)

    // Koloreak ezarri
    iTestuKolorea = ZURI_DISTIRA;   // Zuri-zuria (testuaren kolorea)
    iHondoKolorea = GORRIA;         // Gorria (hondoaren kolorea)
    TestuKoloreaEzarri(iTestuKolorea | iHondoKolorea << 4);  // Koloreak lotzen dira: iTestuKolorea (lehen 4 bitak) eta iHondoKolorea (hurrengo 4 bitak)
    // Testua inprimatu
    printf("  Testua ZURI DISTIRATSUA eta hondoa GORRIA                 \n");
    // Ohiko itxurako koloreak berreskuratu
    TestuKoloreaEzarri(7); // Kolore normalean (testua zuriz eta atzeko planoa beltzez)

    // Koloreak ezarri
    iTestuKolorea = BELTZ_DISTIRA;  // Gris iluna (testuaren kolorea)
    iHondoKolorea = BERDE_DISTIRA;  // Berde distiratsua (hondoaren kolorea)
    TestuKoloreaEzarri(iTestuKolorea | iHondoKolorea << 4);  // Koloreak lotzen dira: iTestuKolorea (lehen 4 bitak) eta iHondoKolorea (hurrengo 4 bitak)
    // Testua inprimatu
    printf("  Testua BELTZ ARGIA (GRISA) eta hondoa BERDE DISTIRATSUA   \n");
    // Ohiko itxurako koloreak berreskuratu
    TestuKoloreaEzarri(7); // Kolore normalean (testua zuriz eta atzeko planoa beltzez)

    // Koloreak ezarri
    iTestuKolorea = MAGENTA;        // Morea (testuaren kolorea)
    iHondoKolorea = BERDEA;         // Berdea (hondoaren kolorea)
    TestuKoloreaEzarri(iTestuKolorea | iHondoKolorea << 4);  // Koloreak lotzen dira: iTestuKolorea (lehen 4 bitak) eta iHondoKolorea (hurrengo 4 bitak)
    // Testua inprimatu
    printf("  Testua MAGENTA (MOREA) eta hondoa BERDEA                  \n");
    // Ohiko itxurako koloreak berreskuratu
    TestuKoloreaEzarri(7); // Kolore normalean (testua zuriz eta atzeko planoa beltzez)

    // Koloreak ezarri
    iTestuKolorea = URDINA;         // Itsas urdina (testuaren kolorea)
    iHondoKolorea = HORI_DISTIRA;   // Hori distiratsua (hondoaren kolorea)
    TestuKoloreaEzarri(iTestuKolorea | iHondoKolorea << 4);  // Koloreak lotzen dira: iTestuKolorea (lehen 4 bitak) eta iHondoKolorea (hurrengo 4 bitak)
    // Testua inprimatu
    printf("  Testua URDINA eta hondoa HORI DISTIRATSUA                 \n");
    // Ohiko itxurako koloreak berreskuratu
    TestuKoloreaEzarri(7); // Kolore normalean (testua zuriz eta atzeko planoa beltzez)

    // Koloreak ezarri
    iTestuKolorea = URDINA;         // Itsas urdina (testuaren kolorea)
    iHondoKolorea = HORIA;          // Hori iluna (hondoaren kolorea)
    TestuKoloreaEzarri(iTestuKolorea | iHondoKolorea << 4);  // Koloreak lotzen dira: iTestuKolorea (lehen 4 bitak) eta iHondoKolorea (hurrengo 4 bitak)
    // Testua inprimatu
    printf("  Testua URDINA eta hondoa HORIA                            \n");
    // Ohiko itxurako koloreak berreskuratu
    TestuKoloreaEzarri(7); // Kolore normalean (testua zuriz eta atzeko planoa beltzez)

    // Koloreak ezarri
    iTestuKolorea = ZURI_DISTIRA;   // Zuri argia (testuaren kolorea)
    iHondoKolorea = URDINA;         // Urdina (hondoaren kolorea)
    TestuKoloreaEzarri(iTestuKolorea | iHondoKolorea << 4);  // Koloreak lotzen dira: iTestuKolorea (lehen 4 bitak) eta iHondoKolorea (hurrengo 4 bitak)
    // Testua inprimatu
    printf("  Testua ZURI DISTIRATSUA eta hondoa URDINA                 \n");
    // Ohiko itxurako koloreak berreskuratu
    TestuKoloreaEzarri(7); // Kolore normalean (testua zuriz eta atzeko planoa beltzez)

    // Koloreak ezarri
    iTestuKolorea = HORI_DISTIRA;   // Hori argia (testuaren kolorea)
    iHondoKolorea = ZYAN_DISTIRA;   // Zyan argia (hondoaren kolorea)
    TestuKoloreaEzarri(iTestuKolorea | iHondoKolorea << 4);  // Koloreak lotzen dira: iTestuKolorea (lehen 4 bitak) eta iHondoKolorea (hurrengo 4 bitak)
    // Testua inprimatu
    printf("  Testua HORI ARGIZ eta hondoa ZYAN ARGIA                   \n");
    // Ohiko itxurako koloreak berreskuratu
    TestuKoloreaEzarri(7); // Kolore normalean (testua zuriz eta atzeko planoa beltzez)

    // Koloreak ezarri
    iTestuKolorea = HORI_DISTIRA;   // Hori argia (testuaren kolorea)
    iHondoKolorea = ZYANA;          // Zyana (hondoaren kolorea)
    TestuKoloreaEzarri(iTestuKolorea | iHondoKolorea << 4);  // Koloreak lotzen dira: iTestuKolorea (lehen 4 bitak) eta iHondoKolorea (hurrengo 4 bitak)
    // Testua inprimatu
    printf("  Testua HORI ARGIZ eta hondoa ZYAN                         \n");
    // Ohiko itxurako koloreak berreskuratu
    TestuKoloreaEzarri(7); // Kolore normalean (testua zuriz eta atzeko planoa beltzez)

    // Koloreak ezarri
    iTestuKolorea = BELTZA;         // Beltza (testuaren kolorea)
    iHondoKolorea = URDIN_DISTIRA;  // Urdin distiratsua (hondoaren kolorea)
    TestuKoloreaEzarri(iTestuKolorea | iHondoKolorea << 4);  // Koloreak lotzen dira: iTestuKolorea (lehen 4 bitak) eta iHondoKolorea (hurrengo 4 bitak)
    // Testua inprimatu
    printf("  Testua BELTZA eta hondoa URDIN DISTIRATSUA                \n");
    // Ohiko itxurako koloreak berreskuratu
    TestuKoloreaEzarri(7); // Kolore normalean (testua zuriz eta atzeko planoa beltzez)

    // Koloreak ezarri
    iTestuKolorea = MAGENTA_DISTIRA;// Magenta argia (testuaren kolorea)
    iHondoKolorea = BELTZA;         // Beltza (hondoaren kolorea)
    TestuKoloreaEzarri(iTestuKolorea | iHondoKolorea << 4);  // Koloreak lotzen dira: iTestuKolorea (lehen 4 bitak) eta iHondoKolorea (hurrengo 4 bitak)
    // Testua inprimatu
    printf("  Testua MAGENTA ARGIZ eta hondoa BELTZA                    \n");
    // Ohiko itxurako koloreak berreskuratu
    TestuKoloreaEzarri(7); // Kolore normalean (testua zuriz eta atzeko planoa beltzez)

    // Koloreak ezarri
    iTestuKolorea = BERDE_DISTIRA;  // Berde argia (testuaren kolorea)
    iHondoKolorea = BELTZ_DISTIRA;  // Beltz argia (hondoaren kolorea)
    TestuKoloreaEzarri(iTestuKolorea | iHondoKolorea << 4);  // Koloreak lotzen dira: iTestuKolorea (lehen 4 bitak) eta iHondoKolorea (hurrengo 4 bitak)
    // Testua inprimatu
    printf("  Testua BERDE ARGIZ eta hondoa BELTZ ARGIA (GRISA)         \n");
    // Ohiko itxurako koloreak berreskuratu
    TestuKoloreaEzarri(7); // Kolore normalean (testua zuriz eta atzeko planoa beltzez)

    // Koloreak ezarri
    iTestuKolorea = GORRI_DISTIRA;  // Gorri argia (testuaren kolorea)
    iHondoKolorea = ZURIA;          // Zuria (hondoaren kolorea)
    TestuKoloreaEzarri(iTestuKolorea | iHondoKolorea << 4);  // Koloreak lotzen dira: iTestuKolorea (lehen 4 bitak) eta iHondoKolorea (hurrengo 4 bitak)
    // Testua inprimatu
    printf("  Testua GORRI ARGIZ eta hondoa ZURIZ                       \n");
    // Ohiko itxurako koloreak berreskuratu
    TestuKoloreaEzarri(7); // Kolore normalean (testua zuriz eta atzeko planoa beltzez)

    // Koloreak ezarri
    iTestuKolorea = GORRIA;         // Gorria (testuaren kolorea)
    iHondoKolorea = ZURI_DISTIRA;   // Zuri distiratsuaa (hondoaren kolorea)
    TestuKoloreaEzarri(iTestuKolorea | iHondoKolorea << 4);  // Koloreak lotzen dira: iTestuKolorea (lehen 4 bitak) eta iHondoKolorea (hurrengo 4 bitak)
    // Testua inprimatu
    printf("  Testua GORRIZ eta hondoa ZURI DISTITATSUZ                 \n");
    // Ohiko itxurako koloreak berreskuratu
    TestuKoloreaEzarri(7); // Kolore normalean (testua zuriz eta atzeko planoa beltzez)

    printf("\n");

    iHondoa = HondoaAukeratu();
    printf("\n\n");
    for (iKont = 0; iKont <= 15; iKont++)
    {
        printf("  %02d  ", iKont);
        // Koloreak ezarri
        iTestuKolorea = iKont;
        iHondoKolorea = iHondoa;
        TestuKoloreaEzarri(iTestuKolorea | iHondoKolorea << 4);  // Koloreak lotzen dira: iTestuKolorea (lehen 4 bitak) eta iHondoKolorea (hurrengo 4 bitak)
        // Testua inprimatu
        printf("  Testuaren kolorea = %02d  eta hondoa %d  ", iKont, iHondoa);
        // Ohiko itxurako koloreak berreskuratu
        TestuKoloreaEzarri(7); // Kolore normalean (zuriz testua eta beltzez atzeko planoa)
        printf("\n");
    }

    printf("\n\n");
    printf("Programa amaitzera doa");
    printf("\n\n");

    return 0;
}






  • Ariketa-74_Koloreak.cbp | main.c  


 

2025(e)ko martxoaren 28(a), ostirala

Ariketa 66 | Koloreak

ZER DAKIDAN:
Informazioa pantailan idazteko printf() funtzioa ezagutzen dut.



ZER IKASIKO DUDAN:
Informazioa koloretan pantailaratzen ikasiko dut.

Kontsolan testu bat idazten denean, bere kolorea eta atributuak aukera daitezke. Artikulo honen beheko aldean dauden tauletan biltzen diren ANSI ihes-sekuentziak kontsolan idazten diren testuen koloreak eta atributuak kontrolatzeko balio dute.

ANSI ihes-sekuentziei esker, kontrol-informazioa bidal daiteke kontsolara, irudikatutako testuaren atributuak aldatzeko. Modu horretan, honako hauek hauta daitezke:

  • Testuaren estiloa:
    • normala 0
    • argia/lauso 1
    • indartua/lodia 2
    • azpimarratua 4
    • klikalaria/keinukaria 5
    • alderantzizkoa 7
    • ezkutukoa 8
  • Hondoaren kolorea
  • Testuaren kolorea

Funtzionamendua erraza da. Kontsolara irteeran bidaltzen den informazioaren artean, testua irudikatzeko jarraibideak ematen dituzten ihes-sekuentziak daude.

Adibidez, printf() funtzioari "%sTestua pantailan%s" parametroa hau ematen bazaio, non lehen %s bitartez testuaren itxura zehazten den eta bigarren %s bitartez testua ohiko itxurar itzultzen duen.

Sintaxia hau izango litzateke:       "\033 [x; xxx; xxxm"

Non x bakoitzak digitu bat irudikatzen duen. Lehen digituak estiloa zehazten du, bigarren digituak hondoren kolorea zehazten du eta hirugarren digituak testuaren kolorea zehazten du.

Esate baterako, hemen kode batzuk eta haien esanahiak:

  • "\033[0;43;36m"       normala, hondoa marroia, testua zyana
  • "\033[4;102;34m"     azpimarratua, hondoa berde distiratsua, testua urdina
  • "\033[5;47;101m"     kliskalaria, hondoa zuria, testua gorri distiratsua
  • "\033[0m"                   ohiko itxurara itzuli

Kode horiek programa batean erabil ditzagun.


/* Ariketa-66_Koloreak: testuen koloreak */

#include <stdio.h>

// ANSI kolore kodeak

// ohikoa berreskuratu
#define RESET   "\033[0m"

// testuaren kolore arruntak
#define BELTZA  "\033[0,30m"
#define GORRIA  "\033[0,31m"
#define BERDEA  "\033[0,32m"
#define MARROIA "\033[0,33m"
#define URDINA  "\033[0,34m"
#define MAGENTA "\033[0,35m"
#define ZYANA   "\033[0,36m"
#define ZURIA   "\033[0,37m"

// testuaren kolore distiratsuak
#define BELTZ_DISTIRATSUA   "\033[90m"
#define GORRI_DISTIRATSUA   "\033[91m"
#define BERDE_DISTIRATSUA   "\033[92m"
#define MARROI_DISTIRATSUA  "\033[93m"
#define URDIN_DISTIRATSUA   "\033[94m"
#define MAGENTA_DISTIRATSUA "\033[95m"
#define ZYAN_DISTIRATSUA    "\033[96m"
#define ZURI_DISTIRATSUA    "\033[97m"

// hondoaren kolore arruntak
#define BELTZ_HONDOA   "\033[0;40m"
#define GORRI_HONDOA   "\033[0;41m"
#define BERDE_HONDOA   "\033[0;42m"
#define MARROI_HONDOA  "\033[0;43m"
#define URDIN_HONDOA   "\033[0;44m"
#define MAGENTA_HONDOA "\033[0;45m"
#define ZYAN_HONDOA    "\033[0;46m"
#define ZURI_HONDOA    "\033[0;47m"

// hondoaren kolore distiratsuak
#define BELTZ_DISTIRATSUA_HONDOA   "\033[0;100m"
#define GORRI_DISTIRATSUA_HONDOA   "\033[0;101m"
#define BERDE_DISTIRATSUA_HONDOA   "\033[0;102m"
#define MARROI_DISTIRATSUA_HONDOA  "\033[0;103m"
#define URDIN_DISTIRATSUA_HONDOA   "\033[0;104m"
#define MAGENTA_DISTIRATSUA_HONDOA "\033[0;105m"
#define ZYAN_DISTIRATSUA_HONDOA    "\033[0;106m"
#define ZURI_DISTIRATSUA_HONDOA    "\033[0;107m"

// konbinazio bat (hiru gai: itxura, hondoa eta testua)
#define Norma__H_BERDEA__T_URDINA "\033[0;44;32m"
#define Lauso__H_BERDEA__T_URDINA "\033[1;44;32m"
#define Betea__H_BERDEA__T_URDINA "\033[2;44;32m"
#define Azpim__H_BERDEA__T_URDINA "\033[4;44;32m"
#define Klisk__H_BERDEA__T_URDINA "\033[5;44;32m"
#define Alder__H_BERDEA__T_URDINA "\033[7;44;32m"

// konbinazio bat (hiru gai: itxura, hondoa eta testua)
#define Norma__H_ZYAN__T_MARROIDISTIRA "\033[0;46;93m"
#define Lauso__H_ZYAN__T_MARROIDISTIRA "\033[1;46;93m"
#define Betea__H_ZYAN__T_MARROIDISTIRA "\033[2;46;93m"
#define Azpim__H_ZYAN__T_MARROIDISTIRA "\033[4;46;93m"
#define Klisk__H_ZYAN__T_MARROIDISTIRA "\033[5;46;93m"
#define Alder__H_ZYAN__T_MARROIDISTIRA "\033[7;46;93m"

// konbinazio bat (hiru gai: itxura, hondoa eta testua)
#define Norma__H_BELTZDISTIRA__T_GORRI "\033[0;100;31m"
#define Lauso__H_BELTZDISTIRA__T_GORRI "\033[1;100;31m"
#define Betea__H_BELTZDISTIRA__T_GORRI "\033[2;100;31m"
#define Azpim__H_BELTZDISTIRA__T_GORRI "\033[4;100;31m"
#define Klisk__H_BELTZDISTIRA__T_GORRI "\033[5;100;31m"
#define Alder__H_BELTZDISTIRA__T_GORRI "\033[7;100;31m"

// konbinazio bat (hiru gai: itxura, hondoa eta testua)
#define Norma__H_MAGENTADISTIRA__T_ZYANA "\033[0;105;36m"
#define Lauso__H_MAGENTADISTIRA__T_ZYANA "\033[1;105;36m"
#define Betea__H_MAGENTADISTIRA__T_ZYANA "\033[2;105;36m"
#define Azpim__H_MAGENTADISTIRA__T_ZYANA "\033[4;105;36m"
#define Klisk__H_MAGENTADISTIRA__T_ZYANA "\033[5;105;36m"
#define Alder__H_MAGENTADISTIRA__T_ZYANA "\033[7;105;36m"

// konbinazio bat (hiru gai: itxura, hondoa eta testua)
#define Norma__H_ZURIDISTIRA__T_URDINA "\033[0;107;34m"
#define Lauso__H_ZURIDISTIRA__T_URDINA "\033[1;107;34m"
#define Betea__H_ZURIDISTIRA__T_URDINA "\033[2;107;34m"
#define Azpim__H_ZURIDISTIRA__T_URDINA "\033[4;107;34m"
#define Klisk__H_ZURIDISTIRA__T_URDINA "\033[5;107;34m"
#define Alder__H_ZURIDISTIRA__T_URDINA "\033[7;107;34m"

// konbinazio bat (hiru gai: itxura, hondoa eta testua)
#define Norma__H_ZURIA__T_GORRIDISTIRA "\033[0;47;91m"
#define Lauso__H_ZURIA__T_GORRIDISTIRA "\033[1;47;91m"
#define Betea__H_ZURIA__T_GORRIDISTIRA "\033[2;47;91m"
#define Azpim__H_ZURIA__T_GORRIDISTIRA "\033[4;47;91m"
#define Klisk__H_ZURIA__T_GORRIDISTIRA "\033[5;47;91m"
#define Alder__H_ZURIA__T_GORRIDISTIRA "\033[7;47;91m"


void Koloreak()
{
    printf("Hondoa BERDE eta testua URDIN:\n");
    printf("\t%sNormala     %s\n", Norma__H_BERDEA__T_URDINA, RESET);
    printf("\t%sLausoa      %s\n", Lauso__H_BERDEA__T_URDINA, RESET);
    printf("\t%sBetea       %s\n", Betea__H_BERDEA__T_URDINA, RESET);
    printf("\t%sAzpimarratua%s\n", Azpim__H_BERDEA__T_URDINA, RESET);
    printf("\t%sKliskagarri %s\n", Klisk__H_BERDEA__T_URDINA, RESET);
    printf("\t%sAlderantziz %s\n", Alder__H_BERDEA__T_URDINA, RESET);
    printf("\n");
    printf("Hondoa ZYAN eta testua MARROI DISTIRATSU:\n");
    printf("\t%sNormala     %s\n", Norma__H_ZYAN__T_MARROIDISTIRA, RESET);
    printf("\t%sLausoa      %s\n", Lauso__H_ZYAN__T_MARROIDISTIRA, RESET);
    printf("\t%sBetea       %s\n", Betea__H_ZYAN__T_MARROIDISTIRA, RESET);
    printf("\t%sAzpimarratua%s\n", Azpim__H_ZYAN__T_MARROIDISTIRA, RESET);
    printf("\t%sKliskagarri %s\n", Klisk__H_ZYAN__T_MARROIDISTIRA, RESET);
    printf("\t%sAlderantziz %s\n", Alder__H_ZYAN__T_MARROIDISTIRA, RESET);
    printf("\n");
    printf("Hondoa BELTZ DISTIRATSUA eta testua GORRI:\n");
    printf("\t%sNormala     %s\n", Norma__H_BELTZDISTIRA__T_GORRI, RESET);
    printf("\t%sLausoa      %s\n", Lauso__H_BELTZDISTIRA__T_GORRI, RESET);
    printf("\t%sBetea       %s\n", Betea__H_BELTZDISTIRA__T_GORRI, RESET);
    printf("\t%sAzpimarratua%s\n", Azpim__H_BELTZDISTIRA__T_GORRI, RESET);
    printf("\t%sKliskagarri %s\n", Klisk__H_BELTZDISTIRA__T_GORRI, RESET);
    printf("\t%sAlderantziz %s\n", Alder__H_BELTZDISTIRA__T_GORRI, RESET);
    printf("\n");
    printf("Hondoa MAGENTA DISTIRATSUA eta testua ZYAN:\n");
    printf("\t%sNormala     %s\n", Norma__H_MAGENTADISTIRA__T_ZYANA, RESET);
    printf("\t%sLausoa      %s\n", Lauso__H_MAGENTADISTIRA__T_ZYANA, RESET);
    printf("\t%sBetea       %s\n", Betea__H_MAGENTADISTIRA__T_ZYANA, RESET);
    printf("\t%sAzpimarratua%s\n", Azpim__H_MAGENTADISTIRA__T_ZYANA, RESET);
    printf("\t%sKliskagarri %s\n", Klisk__H_MAGENTADISTIRA__T_ZYANA, RESET);
    printf("\t%sAlderantziz %s\n", Alder__H_MAGENTADISTIRA__T_ZYANA, RESET);
    printf("\n");
    printf("Hondoa ZURI DISTIRATSUA eta testua URDIN:\n");
    printf("\t%sNormala     %s\n", Norma__H_ZURIDISTIRA__T_URDINA, RESET);
    printf("\t%sLausoa      %s\n", Lauso__H_ZURIDISTIRA__T_URDINA, RESET);
    printf("\t%sBetea       %s\n", Betea__H_ZURIDISTIRA__T_URDINA, RESET);
    printf("\t%sAzpimarratua%s\n", Azpim__H_ZURIDISTIRA__T_URDINA, RESET);
    printf("\t%sKliskagarri %s\n", Klisk__H_ZURIDISTIRA__T_URDINA, RESET);
    printf("\t%sAlderantziz %s\n", Alder__H_ZURIDISTIRA__T_URDINA, RESET);
    printf("\n");
    printf("Hondoa ZURI eta testua GORRI DISTIRATSU:\n");
    printf("\t%sNormala     %s\n", Norma__H_ZURIA__T_GORRIDISTIRA, RESET);
    printf("\t%sLausoa      %s\n", Lauso__H_ZURIA__T_GORRIDISTIRA, RESET);
    printf("\t%sBetea       %s\n", Betea__H_ZURIA__T_GORRIDISTIRA, RESET);
    printf("\t%sAzpimarratua%s\n", Azpim__H_ZURIA__T_GORRIDISTIRA, RESET);
    printf("\t%sKliskagarri %s\n", Klisk__H_ZURIA__T_GORRIDISTIRA, RESET);
    printf("\t%sAlderantziz %s\n", Alder__H_ZURIA__T_GORRIDISTIRA, RESET);
}


int main()
{
    Koloreak();

    printf("\n\n");
    printf("Programa amaitzera doa");
    printf("\n\n");

    return 0;
}




ANSI ihes-sekuentziak: koloreak eta atributuak kontsolan
Kolore arruntak
Kolorea   Kodea
Beltza "\033[0,30m"
Gorria "\033[0,31m"
Berdea "\033[0,32m"
Marroia "\033[0,33m"
Urdina "\033[0,34m"
Magenta "\033[0,35m"
Zyana "\033[0,36m"
Zuria "\033[0,37m"
Lausoak
Kolorea   Kodea
Beltza "\033[1,30m"
Gorria "\033[1,31m"
Berdea "\033[1,32m"
Marroia "\033[1,33m"
Urdina "\033[1,34m"
Magenta "\033[1,35m"
Zyana "\033[1,36m"
Zuria "\033[1,37m"
Bold edo lodiak
Kolorea   Kodea
Beltza "\033[2,30m"
Gorria "\033[2,31m"
Berdea "\033[2,32m"
Marroia "\033[2,33m"
Urdina "\033[2,34m"
Magenta "\033[2,35m"
Zyana "\033[2,36m"
Zuria "\033[2,37m"
Azpimarratuak
Kolorea   Kodea
Beltza "\033[4,30m"
Gorria "\033[4,31m"
Berdea "\033[4,32m"
Marroia "\033[4,33m"
Urdina "\033[4,34m"
Magenta "\033[4,35m"
Zyana "\033[4,36m"
Zuria "\033[4,37m"
Kliskalariak
Kolorea   Kodea
Beltza "\033[5,30m"
Gorria "\033[5,31m"
Berdea "\033[5,32m"
Marroia "\033[5,33m"
Urdina "\033[5,34m"
Magenta "\033[5,35m"
Zyana "\033[5,36m"
Zuria "\033[5,37m"
Alderantzizkoak
Kolorea   Kodea
Beltza "\033[7,30m"
Gorria "\033[7,31m"
Berdea "\033[7,32m"
Marroia "\033[7,33m"
Urdina "\033[7,34m"
Magenta "\033[7,35m"
Zyana "\033[7,36m"
Zuria "\033[2,37m"
Kolore distiratsuak
Kolorea   Kodea
Beltza "\033[0,90m"
Gorria "\033[0,91m"
Berdea "\033[0,92m"
Marroia "\033[0,93m"
Urdina "\033[0,94m"
Magenta "\033[0,95m"
Zyana "\033[0,96m"
Zuria "\033[0,97m"
Hondoak
Kolorea   Kodea
Beltza "\033[0,40m"
Gorria "\033[0,41m"
Berdea "\033[0,42m"
Marroia "\033[0,43m"
Urdina "\033[0,44m"
Magenta "\033[0,45m"
Zyana "\033[0,46m"
Zuria "\033[0,47m"
Hondo distiratsuak
Kolorea   Kodea
Beltza "\033[0,100m"
Gorria "\033[0,101m"
Berdea "\033[0,102m"
Marroia "\033[0,103m"
Urdina "\033[0,104m"
Magenta "\033[0,105m"
Zyana "\033[0,106m"
Zuria "\033[0,107m"
Ohikoa berreskuratzeko
Kolorea   Kodea
Reset "\033[0m"







  • Ariketa-66_Koloreak.cbp | main.c  


 

Liburutegiak

ZER DAKIDAN:
Orain arte, edozein proiekturen kode guztia main.c fitxategian kokatu dut. Baina baliteke proiektu baten kodea iturburu-fitxategi desberdinetan banatzea.



ZER IKASIKO DUDAN:
Orain ikasiko dut proiektu baten kodea bi fitxategietan idazten: fitxategi bat kanpoko liburutegia izango da eta bestea liburutegi horren bezero-programa.







Aurrekariak

Dakigunez programa exekutagarria eskuratzeko iturburu-programaren itzulketa bat burutu behar da, eta horretarako konpiladorearen eta estekatzailearen beharra daukagu. Biak jarraian lan egiten dutelako (lehenik konpiladorea eta ondoren estakatailea) guretzat prozesu bakarra bezala agertzen zaigu. Eskematikoki:

Adibide honetan aritm.h kanpoko liburutegi bat sortuko dugu eta bezero-programak liburutegi horren erabilpena egingo du. Adibide honek kopuru osoak landuko ditu, oinarrizko eragiketa aritmetikoak burutuz. Baina main.c bezero-programatik hasiko gara, honek main() funtzio nagusia barneratzen du.



Programa bat idatziko dugu aritm.h liburutegia erabiliko duena, proiektu honi LiburutegiAdibidea.cbp deituko diogu eta bere funtzio nagusia main() izango da, ikusi Code::Blocks ingurunean main() funtzioa:


Ikusten denez, bezero-programa deitzen den main.c programaren main() funtzio nagusian fitxategi baten sartzea egiten da #include "aritm.h" konpilazio-jarraibideren bitartez. Ondorioz, aritm.h liburutegian garatu diren funtzioak edo definitu diren konstanteak libreki erabil ditzake main.c bezero-programak.

Hauxe da main() funtzio nagusiaren kodea, non ZatiduraEtaHondarra() funtzioa, Batu() funtzioa eta Kendu() funtzioa erabiltzen diren, nahiz eta haien kodea main() funtzio nagusian ez dauden:

/* LiburutegiAdibide.cbp proiektua*/

#include <stdio.h>   // liburutegi estandarra
#include "aritm.h"   // kanpoko liburutegia sartzeko

int main()
{
    int iEragigai1, iEragigai2, iBatura, iKendura, iZatidura, iHondarra;

    printf("\n\n");
    printf("%30s", "Lehen eragigaia eman: ");
    scanf("%d", &iEragigai1);

    do
    {
        printf("%30s", "Bigarren eragigaia eman: ");
        scanf("%d", &iEragigai2);
        if (iEragigai2 == 0)
        {
            printf("%30s\n", "Datua ezin daiteke 0 izan");
        }
    } while (iEragigai2 == 0);

    // Aritmetika funtzioak erabiltzen dira
    iBatura = Batu(iEragigai1, iEragigai2);      // "aritm.h" liburutegian garatuta
    iKendura = Kendu(iEragigai1, iEragigai2);    // "aritm.h" liburutegian garatuta
    ZatiduraEtaHondarra(iEragigai1, iEragigai2,
                        &iZatidura, &iHondarra); // "aritm.h" liburutegian garatuta

    printf("\n");
    printf("%15d + %d = %d\n", iEragigai1, iEragigai2, iBatura);
    printf("%15d - %d = %d\n", iEragigai1, iEragigai2, iKendura);
    printf("%15d / %d = %d\n", iEragigai1, iEragigai2, iZatidura);
    printf("%15d %% %d = %d\n", iEragigai1, iEragigai2, iHondarra);

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

Baina ikas dezagun #include konpilazio-direktibak edo jarraibideak behar duen sintaxia:  

                #include "aritm.h"
#include aurre-prozesadorearen jarraibideari fitxategia sartzea esaten zaio eta, dakigunez, bere sintaxia #include <FitxategiIzen> da, edo bestela beste sintaxi hau onargarria da ere #include "FitxategiIzen". Sintaxi bien arteko aldea honela adierazten da:
  • #include <FitxategiIzen> erabiltzean, sartu beharreko FitxategiIzen izeneko fitxategia konpiladoreak duen karpeta batean hasiko da bilatzen
  • #include "FitxategiIzen" erabiltzean, sartu beharreko FitxategiIzen izeneko fitxategia proiektuaren karpetan hasiko da bilatzen


#include "aritm.h" liburutegia honelaxe gehitzen da proiektura. zalpenak bost urrats ditu:  

1/5

Programazio-inguruneko menuan  File > New > File...  aukera hautatu ondoren C header fitxategi-mota aukeratu

2/5

Jarraian, liburutegiaren izena eta bidea zehaztuko dira

3/5

Hurrengo leiho honen bitartez liburutegia gehituko zaio proiektuari, proiektuari dagokion bidea zehaztu

4/5

Proiektuaren Headers karpetan egongo da liburutegia, konpilazio baldintzatuaren jarraibieak kendu

5/5

Liburutegiaren kodea idatzi, bertako funtzioak eta konstanteak eskuragarri dira bezero-programarentzat

Azken urratsa liburutegiaren kodea idaztea da. Dagokigun aritm.h liburutegiaren iturburu-kodea hauxe da, non ZatiduraEtaHondarra() funtzioa, Batu() funtzioa eta Kendu() funtzioa programatu diren, eta main() funtzio nagusiak erabil ditzakeen:  

/* "aritm.h" liburutegiaren kodea */

void ZatiduraEtaHondarra(int iZbk1,
                         int iZbk2,
                         int *iZati, // irteera
                         int *iHond) // irteera
{
    *iZati = iZbk1 / iZbk2;
    *iHond = iZbk1 % iZbk2;
}

int Batu(int iZbk1, int iZbk2)
{
    return iZbk1 + iZbk2;
}

int Kendu(int iZbk1, int iZbk2)
{
    return iZbk1 - iZbk2;
}


LiburutegiAdibidea.cbp proiektua konpilatzean, main.c bezero-programaren iturburu-kodea eta aritm.h liburutegiaren iturburu-kodea konpilatzen dira, haien objektu-programak estekatu egiten dira LiburutegiAdibidea.exe programa exekutagarria eskuratzeko.

Konpilatu/Estekatu ekintzen eskema:







  • LiburutegiAdibidea.cbp | main.c                [bezero-programa]
  • LiburutegiAdibidea.cbp | aritm.h               [kanpoko liburutegia]


 

Konpiladorea eta estekatzailea






Aurrekariak

Dakigunez ordenadore baten funtzionamendua programa batek gidatzen du. Baina, defini dezagun programa bat zer den informatikaren arloan:

Programa: Ordenagailu bati programazio-lengoaia batean idatzita ematen zaion agindu-segida, lan jakin bat egiteko behar diren oinarrizko eragiketak ordenagailuak exkutatzeko moduan zehatz-mehatz azaltzen dituena. 

Baina ez dugu ahaztu behar ordenagailua makina digitala dela eta exekuta dezakeen programa berari dagokion makina-kodean idatzirik eman behar zaiola.

Makina-kode: makina-kodea edo makina-programa ordenadoreak ulertzen duen agindu-multzoa da. Ordenagailuaren PUZak (prozesatzeko unitate zentralak) zuzenean, itzulpenik gabe, exekuta dezakeen agindu-multzoa. Agindu horiek sistema bitarrean adierazten dira eta bakoitzak eragiketa aritmetiko edo logiko bat adierazten du. Ordenagailu batetik bestera alda daiteke. 

Modu beretsuan, ez dugu ahaztu behar guk goi-mailako lengoaiaren bat erabiliko dugula programa idazteko eta horregatik gure programa "itzuli" beharko dela ordenadoreak exekuta dezan. Hori dela eta, guk idatzitako programari iturburu-programa esaten zaio, hauxe da bere definizioa.

Iturburu-programa: iturburu-programa edo iturburu-kodea goi-mailako lengoaian idatzitako sententzia eta aginduen multzoa da. Ordenagailuak exekutatu ahal izateko konpiladore, mihiztatzaile edo interpretatzaileen bidez makina-lengoaiara bihurtu behar dena, hots, iturburu-programa itzuli beharra dago ordenadoreak exekuta dezan.  

Eskematikoki:

Adibidean ikusten denez, iturburu-programa C lengoaian idatzita dago eta itzultzailea GNU GCC Compiler
konpiladorea litzateke. Baina eskema honek balio du ere edozein goi-mailako programazio-lengoaiarako.

Iturburu-programa itzuli beharra dagoela eta, goi-mailako lengoaian bi motatakoak izan daitezke: Interpretatuak eta Konpilatuak. Goi-mailako lengoaia interpretatuetan interpretatzaile bat aplikatzen zaio programari makina-kodea lortzeko. Goi-mailako lengoaia konpilatuetan programaren itzultzaile lana konpiladoreak egingo du.

Interpretatzaile: Goi-mailako lengoaia itzultzeko programa orokorra da, aginduak irakurri ahala aztertu eta exekutatzen dituena. Goi-mailako lengoaia interpretatuen adibideak: Python, PHP, Perl, MATLAB, Ruby, JavaScript, ... 

Konpiladore: Goi-mailako lengoaian idatzitako programa oso bat hartu eta itzuli edo konpilatzen duen programa da. Goi-mailako lengoaia konpilatuen adibideak: Pascal, C, C++, ... 

Informatikaren arloan konpilatzea iturburu-programa bat itzultzea da, ordenadore baten makina-kodera itzultzea alegia. Konpilatze prozesuak fase desberdinak ditu eta horiekin ez da programa exekutagarria lortzen, konpilatzeari beste estekatzea gehitu behar baitzaio.

Konpilatzearen faseak ondoko irudian erakusten dira:

Non bost fase hauek desberdintzen diren:

  1. Analisi lexikala: Lexikoaren analisia, hitzen analisia, lehenengo fasea da; hemen iturburu-programa (.c luzapena edo .h luzapena duen kodea) ezkerretik eskuinera irakurtzen da eta osagai lexikoetan (tokenak) biltzen da, esanahi bat duten karaktere-sekuentziak direnak. Gainera, zuriune guztiak, lerro zuriak, iruzkinak eta beharrezkoa ez den gainerako informazioa iturburu-programatik ezabatzen da. Lengoaiaren sinboloak (hitz gakoak, eragileak, etab.) behar bezala idatzi direla ere egiaztatzen da. Adibidez, fase honetan aurkitzen dira ";" baten falta, edo ">=" ordez "=>" idatzi dela, edo aldagai baten etiketa okerra, edo etiketa bera bikoiztuta dagoela
  2. Analisi sintaktikoa: Fase honetan, tokenak edo osagai lexikoak hierarkikoki biltzen dira gramatika-esaldietan, eta horiek konpiladoreak erabiltzen ditu bere irteera sintetizatzeko. Aurreko fasetik lortutakoa sintaktikoki zuzena den egiaztatzen da (lengoaiaren gramatikaren araberakoa da). Oro har, iturburu-programaren esaldi gramatikalak analisi sintaktikoko zuhaitz baten bidez adierazten dira. Adibidez, fase honetan parekatzen dira adierazpen desberdinen () parentesi bikoteak edo {} giltz bikoteak
  3. Analisi semantikoa: Analisi semantikoaren faseak iturburu-programa berrikusten du akats semantikoak aurkitzen saiatzeko, eta datu-motei buruzko informazioa biltzen du kodea sortzeko ondorengo faserako. Analisi semantikoaren zeregin garrantzitsu bat datu-motak egiaztatzea da. Hemen, konpiladoreak operadore bakoitzak iturburu-lengoaiaren espezifikazioagatik baimendutako operandoak dituen egiaztatuko du. Adibidez, string datu-motako aldagai bati zenbaki erreal ezingo zaio esleitu, edo % operadore aritmetikoa ezin zaio karaktere-kate bati aplikatu
  4. Kodearen sortzea: Sintesi-fasea honetan iturburu-programaren baliokidea den objektu-kodea sortzean datza. Iturburu-programak analisi-akatsik ez duenean bakarrik sortzen da objektu-kodea; horrek ez du esan nahi programa behar bezala exekutatuko denik, programa batek kontzeptu-akatsak edo gaizki kalkulatutako esamoldeak izan baititzake
  5. Kodearen optimizatzea: Kodea optimizatzeko fasea bitarteko kodea hobetzean datza, exekutatzeko makina-kode azkarragoa izan dadin. Alde handia dago konpiladoreek exekutatzen duten kode-optimizazioaren kopuruan. Optimizazio handia egiten dutenetan, "Konpiladore optimizatzaileak" deituak, konpiladorearen denboraren zati esanguratsu bat fase honetan luzatzen da. Hala ere, optimizazio sinple batzuk nabarmen hobetzen dute objektu-programa gauzatzeko denbora, konpilazioa gehiegi atzeratu gabe

Objektu-kodea eta objektu-programa aipatu dira goian, izan ere konpilatzearen emaitza .o luzapena, edo .obj luzapena duen fitxategi bat izango da eta fitxategi horri objektu-programa esaten zaio. Objektu-programaren fitxategi hau, makina-kodean idatzita egon arren ezin da exekutatu programa-liburutegien kodea falta zaiolako. Linker edo estekatzaile delako programak objektu-kodetik abiatuta .exe luzapeneko programa-exekutagarria lortuko du.



Estekatu aditzaren esanahia lotu edo elkartu da. Esan bezala, linker edo estekatzaile delako programak .obj (edo .o luzapena) objektu-kodetik abiatuta .exe luzapeneko programa-exekutagarria lortuko du, objektu-kodeari falta zaizkion programa-liburutegiak gehituz. Baina, programa-liburutegiaren eta estekatzailearen definizioak eman ditzagun.

Programa-liburutegi: Programatzaileen eskueran dauden prozedura edo programa prekonpilatuen multzoa. 

Iturburu-programa konpilatu ondoen lortzen den objektu-kodeari aurredefinituriko prozedura eta funtzioak falta zaizkio. Prozedura eta funtzio horiek programa-liburutegietan bildurik daude makina-kodean itzulirik. Estekatzaile delako programak objektu-kodea eta programa-liburutegiak lotu/elkartu egiten egiten ditu. 

Estekatzaile: Independenteki idatzi eta independenteki konpilatu programa edo moduluak elkarrekin lotu eta programa exekutagarri koherente bat eratzen duen programa. 

Eskema honetan bi urratseko prozesua erakusten da Pascal lengoaiarako, non iturburu-kodearen luzapena .pas den eta objektu-kodearen luzapenak .ow edo.ppw diren:

Irudi honetan ere Pascal lengoaiaren kasua erakusten da, baina funtsean C lengoaian berdina da.

Baina non aurkitzen dira .ow eta .ppw luzapeneko prekonpilatutako moduluak? Dev-Pas konpiladorearen kasuan, irudi honek adierazten digu modulu horiek estekatzaileak non bilatuko dituen; konpiladorea C:\Dev-Pas karpetan instalatu bada, unitate prekonpilatuak C:\Dev-Pas\units\rtl karpetan kokatuko dira:

Aurrekonpilatutako moduluen kokapena diskoan Pascal konpiladore baten kasuan

Unitateen eta liburutegien direktorio horiek Dev-Pas konpilazio-ingurunea instalatzean ezartzen dira, behar izanez gero Options > Compiler options > Directories bidea jarraituz alda ditzakegu:

Liburutegien direktorioak Dev-Pas konpilazio-ingurunereako

C eta C++ lengoaiekin lan egiteko, MinGW konpiladorearen kasuan, aurrekonpilatutako moduluak lib liburutegiko karpetan daude.

 

2025(e)ko martxoaren 21(a), ostirala

Kate bat hartu: scanf(), gets() eta fgets()

ZER DAKIDAN:
Array datu-mota ezagutzen dut, eta kateak deritzen char datu-motako elementuen arrayak ezagutzen ditut ere.



ZER IKASIKO DUDAN:
Karaktere-kateak teklatutik irakurtzeko funtzio desberdinak erabiliko ditut:
  • gets() eta scanf()
  • fgets()
Gai honek jarraipena izango du Ariketa 52 | Bi kate irakurtzen artikuluan.


Kate bat hartu eta pantailaratu: gets() eta puts() funtzioak

Hurrengo lehen programan, kate bati balioa emateko bi irakurketa egiten dira teklatuaren bitartez. Lehen irakurketaren aginduak hauek dira:

      scanf("%s", sKatea);
      fflush(stdin);  // teklatuaren bufferra garbitzeko

Eta bigarren irakurketaren agindua hau da:

      gets(sKatea);

Zer gertatzen da gets(sKatea) egitean katearen neurri fisikoa gainditzen bada? Galdera honi erantzuten dio hurrengo bigarren programak.


Programa hau exekutatu eta ikusi bi irakurketen arteko aldea:

/* GETS-PUTS_funtzioak-1: katea irakurtzeko scanf() funtzioa ez da egokia izaten. */
// Karaktere-kateak '\0' markaz bukatzen diren arrayak dira C lengoaian // scanf() funtzioa bukatu egiten da banatzaile bat aurkitzean, adibidez espazio bat. #include <stdio.h> #include <string.h> // gets(), puts() eta strlen() funtzioetarako #include <conio.h> // getch() funtziorako #define MAXIMOA 16 // katea mugatzeko konstantea, // 15 karaktere + null mugatzailea int main() { char sKatea[MAXIMOA] = ""; // 16 null int iKont; printf("\n"); printf("\n char sKatea[MAXIMOA]=\"\"; // hasieraketarekin"); printf("\n Luzera=%d sKatea=|%s| puts()=", (int)strlen(sKatea), sKatea); puts(sKatea); printf(" ASCII KODEA KARAKTEREA"); printf("\n ----------- ----------"); for (iKont=0; iKont < strlen(sKatea)+1; iKont++) { printf("\n sKatea[%d]=%3d sKatea[%d]=%c", iKont, (int)sKatea[iKont], iKont, sKatea[iKont]); if (iKont == strlen(sKatea)) printf(" <-- null marka"); } printf("\n"); printf("\n Zure izena eman (adibidez, Jon Ander): "); scanf("%s", sKatea); fflush(stdin); // teklatuaren bufferra garbitzeko printf(" scanf(\"%%s\", sKatea); // irakurketarekin"); printf("\n Luzera=%d sKatea=|%s| puts()=", (int)strlen(sKatea), sKatea); puts(sKatea); printf(" ASCII KODEA KARAKTEREA"); printf("\n ----------- ----------"); for (iKont=0; iKont < strlen(sKatea)+1; iKont++) { printf("\n sKatea[%d]=%3d sKatea[%d]=%c", iKont, (int)sKatea[iKont], iKont, sKatea[iKont]); if (iKont == strlen(sKatea)) printf(" <-- null marka"); } printf("\n"); printf("\n Zure izena eman (adibidez, Ana Mari): "); gets(sKatea); printf(" gets(sKatea); // irakurketarekin"); printf("\n Luzera=%d sKatea=|%s| puts()=", (int)strlen(sKatea), sKatea); puts(sKatea); printf(" ASCII KODEA KARAKTEREA"); printf("\n ----------- ----------"); for (iKont=0; iKont < strlen(sKatea)+1; iKont++) { printf("\n sKatea[%d]=%3d sKatea[%d]=%c", iKont, (int)sKatea[iKont], iKont, sKatea[iKont]); if (iKont == strlen(sKatea)) printf(" <-- null marka"); } printf("\n\n\n Edozein tekla sakatu exekuzioa amaitzeko... "); getch(); printf("\n"); return 0; }


Programa hau exekutatu eta aztertu sKatea aldagaiari dagokion memorian gordetzen dena:

/* GETS-PUTS_funtzioak-2: katea irakurtzeen ez gainditu memoriako erreserba. */
// Karaktere-kateak '\0' markaz bukatzen diren arrayak dira C lengoaian // Zer gertatzen da gets() funtzioaren bitartez MAXIMOA+2 karaktere sartzean? // strcmp() funtzioa erabiltzen da kateen arteko alderaketak egiteko // strlen() funtzioa erabiltzen da katearen luzera efektiboa lortzeko #include <stdio.h> #include <string.h> // gets(), strcmp() eta strlen() funtzioetarako #include <conio.h> // getch() funtziorako #define MAXIMOA 4 // katea mugatzeko konstantea, // 3 karaktere + null mugatzailea int main() { char sKatea[MAXIMOA]; int iKont; printf("\n"); printf("\n Katearen neurri MAXIMOA = %d karaktere (3 karaktere + null)", MAXIMOA); printf("\n\n"); do { printf(" %d karaktereko katea eman (sartu 0123456 katea): ", MAXIMOA+3); gets(sKatea); } while (strcmp(sKatea, "0123456") != 0); printf("\n ASCII KODEA KARAKTEREA"); printf("\n ----------- ----------"); for (iKont=0; iKont < MAXIMOA+3; iKont++) { printf("\n sKatea[%d]=%3d sKatea[%d]=%c", iKont, (int)sKatea[iKont], iKont, sKatea[iKont]); if (iKont < MAXIMOA) printf(" <-- erreserbatutako posizioa"); if ((iKont >= MAXIMOA) && (iKont < MAXIMOA+2)) printf(" <-- edozein karaktere"); if (iKont == MAXIMOA+2) printf(" <-- null karakterea"); } printf("\n"); do { printf("\n Gehienez %d karaktereko katea eman (adibidez, 01): ", MAXIMOA-1); gets(sKatea); } while (strlen(sKatea) >= MAXIMOA); printf("\n ASCII KODEA KARAKTEREA"); printf("\n ----------- ----------"); for (iKont=0; iKont <= strlen(sKatea); iKont++) { printf("\n sKatea[%d]=%3d sKatea[%d]=%c", iKont, (int)sKatea[iKont], iKont, sKatea[iKont]); if (iKont == strlen(sKatea)) printf(" <-- null karakterea"); } printf("\n\n\n Edozein tekla sakatu exekuzioa amaitzeko... "); getch(); printf("\n"); return 0; }


Kate bat irakurriko dugu, jakinik gehienez 6 datu-karaktere gorde ditzakeela, dakigulako 6 indizea duen zazpigarren posizioa \0 null karaktereari dagokiola. Programa honek bi egoera erakusten ditu:

  1. Ezarririk dagoen muga gainditzean fgets() funtzioak datua mozten du eta 6 indizedun zazpigarren posizioan \0 null karakterea jartzen du. Kontuz, mozturik geratu den zatiarekin, ez badugu teklatuaren bufferra garbitzen fflush(stdin) bitartez, hondarreko karaktere horiek hurrengo irakurketan erabiliko direlako.
  2. Ezarririk dagoen muga gainditzen ez bada, fgets() funtzioaren irakurketa amaiarazteko \n RETURN karakterea sakatu behar da teklatuan. Baina \n RETURN karakterea gorderik geratuko da katean (katearen bukaera bikote honek osatzen duela \n\0), eta horrelakorik ez dugulako nahi \n RETURN karakterea ezabatu beharko da katearen amaiera \0\0 izan dadin.
/* FGETS_funtzioa: kate bat irakurri haren neurria kontrolatuz. */

// fgets() funtzioa fitxategiekin lan egiteko asmatu da, baina
// stdin sarrera estandarra fitxategi baten itxura hartzen duenez
// kateak teklatuaren bitartez irakurtzean erabiliko dugu.

#include <stdio.h>
#include <string.h>    // fgets() eta strlen() funtzioetarako
#include <conio.h>     // getch() funtziorako

#define MAXIMOA 7     // katea mugatzeko konstantea,
                      // 6 karaktere + null mugatzailea
int main()
{
    char sKatea[MAXIMOA];  // 6 karaktere + null gordetzeko katea

    printf("\n\n ----Lehen kasua: maximoa baino karaktere gehiago sartzean-------------\n");

    printf("\n Karaktere kopuru maximoa %d izan arren, ondoko datu luzea eman...", MAXIMOA-1);
    printf("\n Lehen katea eman (adibidez, luzeegia den hau 123456789): ");
    fgets(sKatea, MAXIMOA, stdin);
    fflush(stdin);   // teklatuaren bufferra garbitu
    printf(" Lehen katea sKatea=|%s|      %d karaktere", sKatea, strlen(sKatea));

    printf("\n\n");

    printf("\n\n ----Bigarren kasua: irakurketa RETURN bitartez amaiaraztean-----------\n");

    printf("\n Karaktere kopuru maximoa %d delako, muga hori ez gainditu...", MAXIMOA-1);
    printf("\n Bigarren katea laburra izan dadila (adibidez, 9876): ");
    fgets(sKatea, MAXIMOA, stdin);
    // fflush(stdin);   // programa honetan agindu hau soberan egon daiteke
    printf(" Bigarren katearen luzera %d karaktere, null marka ere hartu duelako\n", (int)strlen(sKatea));
    // if (sKatea[strlen(sKatea)-1] == '\n')  // RETURN azkena izango da
        sKatea[strlen(sKatea)-1] = '\0';      // RETURN karakterea kendu
    printf(" Bigarren katea null marka kendu ondoren sKatea=|%s|    %d karaktere", sKatea, (int)strlen(sKatea));

    printf("\n\n Edozein tekla sakatu exekuzioa amaitzeko... ");
    getch();

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






  • GETS-PUTS_funtzioak-1.cbp | main.c  
  • GETS-PUTS_funtzioak-2.cbp | main.c  
  • FGETS_funtzioa.cbp | main.c