C lengoaia ☀ ariketak: Ariketa 67

ZER DAKIDAN:
Datu-mota soiletan, besteak beste int, char, float ezagutzen ditut. Datu-mota egituratuetan array datu-mota ezagutzen dut (eta datu-mota izan gabe karaktere-kateak ezagutzen ditut).

ZER IKASIKO DUDAN:
Orain estruktura edo struct datu-mota ikasiko dut eta, hurrengo urrats bezala, estrukturen arrayak erabili ahalko ditut.

Estruktura bat erabili ahal izateko, lehenik datu-motaren diseinua egin behar da (programaren hasi-hasieran) eta ondoren estruktura-aldagaiak deklaratuko dira.

Estruktura bat hainbat eremuk edo kidek osatzen dute. Arrayetan ez bezala, eremuak edo kideak edozein datu-motakoak izan daitezke eta kide bakoitzari bere identifikadorea dagokio. Adibidez, hona hemen hiru eremu edo kide dituen estruktura datu-mota bat:

/* Estruktura baten datu-mota programa nagusiaren hasieran diseinatzen da. */

#include <stdio.h>

#define LUZERAMAX 39+1

// Estrukturaren datu-mota definitzen, definizio orokorra programa osorako
struct tstIkaslea
{
  char sIzena[LUZERAMAX];
  int iAdina;
  float fNota;
};   

// Funtzioen prototipoak
void EstrukturaBete(struct tstIkaslea *stIkasleBat);          // deia:  EstrukturaBete(&stIkasle_1);
void EstrukturaPantailaratu(struct tstIkaslea stIkasleBat);   // deia:  EstrukturaPantailaratu(stIkasle_1);

// Programa nagusia
int main()
{
    struct tstIkaslea stIkasle_1;   // estruktura-aldagaia
    struct tstIkaslea stIkasle_2;   // estruktura-aldagaia

    // programa nagusiko gainerako aginduak
}

// Funtzioaren garapena
void EstrukturaBete(struct tstIkaslea *stIkasleBat)
{
    // funtzioaren aginduak
}

Parametroak izatean float, int eta char datu-motak bezalaxe jokatzen dute estrukturek: balioz edo erreferentziaz pasatu ahal dira funtzioetara. Balioz sarrerakoa denean eta erreferentziaz sarrera/irteerakoa denean, gogoratu Ariketa 38 | Zenbaki Konbinatorioa (sarrera-irteerako parametroa) adibidea.

Estruktura osoa funtziora pasatu ordez, estrukturari seinalatzen dion erakuslea pasatuko dugu gehienetan. Beraz, gehienetan, estrukturak erreferentziaz pasatuko dira funtzioetara. Estruktura sarrerakoa izatean babestutako erreferentzia konstante bat izango da eta, aldiz, estruktura sarrera/irteerakoa izatean erreferentzia normal izango da. Honelaxe:

                  /* sarrerako erakuslea */
void EstrukturaIkusi(const struct tstEstrukturaMota *stEstrukturaParametroa);
// EstrukturaIkusi(&stEstrukturaAldagaia);   /* deia */
                   /* sarrera/irteerako erakuslea */
void EstrukturaAldatu(struct tstEstrukturaMota *stEstrukturaParametroa);
// EstrukturaAldatu(&stEstrukturaAldagaia);  /* deia */

Programa honetan hiru eremuko estruktura-aldagai batzuk sortuko dira eta datuz bete ondoren, haiek edukiak erakutsiko dira pantailan. Bi lanak, datuz betetzea eta edukia pantailaratzea funtzio desberdinetan egiten dira.

Programa honen funtzio guztiak ondo daude, baina batzuk besteak baino gomendagarriagoak dira: funtzio batek estruktura bat landu beharko duenean estruktura-aldagai bera bidali beharrean estrukturari seinalatzen dion erakuslea pasatuko diogu funtzioari.

/* Ariketa-67_EstrukturaSoilBat: estruktura bat datuz bete eta
                                 bere edukia pantailaratu. */

// Programa honetan funtzio desberdinak erabiltzen dira, denak daude
// ondo baina batzuk besteak baino hobeto daude: funtzioak estruktura
// bat landu beharko duenean estruktura-aldagai bera bidali beharrean
// estrukturari seinalatzen dion erakuslea pasatuko diogu funtzioari.

// Parametroak izatean float, int eta char datu-motak bezalaxe jokatzen
// dute estrukturek: balioz edo erreferentziaz pasatu ahal dira funtzioetara.
// Balioz sarrerakoa denean eta erreferentziaz sarrera/irteerakoa denean.

// Estruktura osoa funtziora pasatu ordez, estrukturari seinalatzen dion
// erakuslea pasatuko dugu gehienetan. Beraz, gehienetan, estrukturak
// erreferentziaz pasatuko dira funtzioetara. Estruktura sarrerakoa izatean
// babestutako erreferentzia konstante bat izango da eta, aldiz, estruktura
// sarrera/irteerakoa izatean erreferentzia normal izango da. Honelaxe:

// void EstrukturaIkusi(const struct tstEstrukturaMota *stEstrukturaParametroa);
// EstrukturaIkusi(&stEstrukturaAldagaia);   /* deia */
// void EstrukturaAldatu(struct tstEstrukturaMota *stEstrukturaParametroa);
// EstrukturaAldatu(&stEstrukturaAldagaia);  /* deia */

#include <stdio.h>
#include <string.h>   // strcat() funtziorako

#define LUZERAMAX 39+1

// Estrukturaren datu-mota definitzen,
// definizio orokorra programa osorako
struct tstIkaslea
{
  char sIzena[LUZERAMAX];
  int iAdina;
  float fNota;
};

void EstrukturaPantailaratu_A(struct tstIkaslea stIkasleBat);        // deia:  EstrukturaPantailaratu_A(stIkasle_1);
void EstrukturaPantailaratu_B(const struct tstIkaslea *stIkasleBat); // deia:  EstrukturaPantailaratu_B(&stIkasle_1);
struct tstIkaslea EstrukturaBete_A(void);                            // deia:  stIkasle_1 = EstrukturaBete_A();
void EstrukturaBete_B1(struct tstIkaslea *stIkasleBat);              // deia:  EstrukturaBete_B1(&stIkasle_2);
void EstrukturaBete_B2(struct tstIkaslea *stIkasleBat);              // deia:  EstrukturaBete_B2(&stIkasle_3);
void EstrukturaAldatu(struct tstIkaslea *stIkasleBat);               // deia:  EstrukturaAldatu(&stIkasle_4);


int main()
{
    struct tstIkaslea stIkasle_1 = {"Jon Ander", 19, 7.5};
    struct tstIkaslea stIkasle_2;
    struct tstIkaslea stIkasle_3;
    struct tstIkaslea stIkasle_4;

    printf("\n \t==========================================");
    printf("\n \t Estrukturak elikatzen eta pantailaratzen");
    printf("\n \t==========================================\n");

    printf("\n\n \t =======================================");
    printf("\n \t stIkasle_1 (hasieratuta):");
    printf("\n \t EstrukturaPantailaratu_A(stIkasle_1);");
    EstrukturaPantailaratu_A(stIkasle_1);

    printf("\n\n\n \t =======================================");
    printf("\n \t &stIkasle_1 (hasieratuta):");
    printf("\n \t EstrukturaPantailaratu_B(&stIkasle_1);");
    EstrukturaPantailaratu_B(&stIkasle_1);

    printf("\n\n\n \t =======================================");
    printf("\n \t stIkasle_1 (return):");
    printf("\n \t stIkasle_1 = EstrukturaBete_A();");
    stIkasle_1 = EstrukturaBete_A();
    printf("\n \t EstrukturaPantailaratu_A(stIkasle_1);");
    EstrukturaPantailaratu_A(stIkasle_1);

    printf("\n\n\n \t =======================================");
    printf("\n \t &stIkasle_2 (-> operadorez):");
    printf("\n \t EstrukturaBete_B1(&stIkasle_2);");
    EstrukturaBete_B1(&stIkasle_2);
    printf("\n \t EstrukturaPantailaratu_B(&stIkasle_2);");
    EstrukturaPantailaratu_B(&stIkasle_2);

    printf("\n\n\n \t =======================================");
    printf("\n \t &stIkasle_3 (. operadorez):");
    printf("\n \t EstrukturaBete_B2(&stIkasle_3);");
    EstrukturaBete_B2(&stIkasle_3);
    printf("\n \t EstrukturaPantailaratu_B(&stIkasle_3);");
    EstrukturaPantailaratu_B(&stIkasle_3);

    printf("\n\n\n \t =======================================");
    stIkasle_4 = stIkasle_2;
    printf("\n \t stIkasle_4 = stIkasle_2;  // esleipena");
    printf("\n \t EstrukturaPantailaratu_B(&stIkasle_4);");
    EstrukturaPantailaratu_B(&stIkasle_4);

    printf("\n\n\n \t =======================================");
    printf("\n \t &stIkasle_4 (aldatuz)");
    EstrukturaAldatu(&stIkasle_4);
    printf("\n \t EstrukturaPantailaratu_B(&stIkasle_4);");
    EstrukturaPantailaratu_B(&stIkasle_4);

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


void EstrukturaPantailaratu_A(struct tstIkaslea stIkasleBat)
{
    printf("\n \t ---------------------------------------");
    printf("\n \t Izena: %s", stIkasleBat.sIzena);
    printf("\n \t Adina: %d", stIkasleBat.iAdina);
    printf("\n \t Nota:  %.2f", stIkasleBat.fNota);
    printf("\n \t =======================================");
}


void EstrukturaPantailaratu_B(const struct tstIkaslea *stIkasleBat)
{
    printf("\n \t ---------------------------------------");
    printf("\n \t Izena: %s", stIkasleBat->sIzena);
    printf("\n \t Adina: %d", stIkasleBat->iAdina);
    printf("\n \t Nota:  %.2f", stIkasleBat->fNota);
    printf("\n \t =======================================");
}


struct tstIkaslea EstrukturaBete_A(void)
{
    struct tstIkaslea stLaguntzailea;

    printf("\n \t ---------------------------------------");
    printf("\n \t Izena eman: ");
    gets(stLaguntzailea.sIzena);
    // edo scanf("%s", stIkasleBat->sIzena);
    printf(" \t Adina eman: ");
    scanf("%d", &stLaguntzailea.iAdina);
    printf(" \t Nota eman:  ");
    scanf("%f", &stLaguntzailea.fNota);
    printf(" \t =======================================");
    fflush(stdin);

    return stLaguntzailea;
}


void EstrukturaBete_B1(struct tstIkaslea *stIkasleBat)
{
    printf("\n \t ---------------------------------------");
    printf("\n \t Izena eman: ");
    gets(stIkasleBat->sIzena);
    // edo scanf("%s", stIkasleBat->sIzena);
    printf(" \t Adina eman: ");
    scanf("%d", &stIkasleBat->iAdina);
    printf(" \t Nota eman:  ");
    scanf("%f", &stIkasleBat->fNota);
    printf(" \t =======================================");
    fflush(stdin);
}


void EstrukturaBete_B2(struct tstIkaslea *stIkasleBat)
{
    struct tstIkaslea stLaguntzailea;

    printf("\n \t ---------------------------------------");
    printf("\n \t Izena eman: ");
    gets(stLaguntzailea.sIzena);
    // edo scanf("%s", stIkasleBat->sIzena);
    printf(" \t Adina eman: ");
    scanf("%d", &stLaguntzailea.iAdina);
    printf(" \t Nota eman:  ");
    scanf("%f", &stLaguntzailea.fNota);
    printf(" \t =======================================");
    fflush(stdin);

    *stIkasleBat = stLaguntzailea;
}


void EstrukturaAldatu(struct tstIkaslea *stIkasleBat)
{
    strcat(stIkasleBat->sIzena, "txo");
    stIkasleBat->iAdina = stIkasleBat->iAdina + 1;
    stIkasleBat->fNota = stIkasleBat->fNota * 1.1;
}

Estrukturak parametro bezala

Estruktura bat hainbat eremuk osatzen dute eta estrukturaren hasieraketa egin daiteke arrayak hasieratzen diren bezala.

Estruktura bat funtzio baten parametroa izango denean, bi modutan pasa daiteke funtziora: balioz eta erreferentziaz. Beraz, estrukturak nahiz eta datu-mota egituratuak izan, float edo int edo char edo gainerako datu-mota xeheak bezala erabili ahal dira. Baina, ...

...konputazioa azkarragoa izan dadin, estrukturak arrayak bezala pasatuko ditugu funtzioetara: erreferentziaz. Estruktura sarrerakoa denean erreferentzia konstante babestua const markarekin eta estruktura sarrera/irteerakoa denean erreferentzia arrunta bezala.

Erakusten den programa honetan, datu-mota desberdineko aldagaiak sortu eta hasieratu egiten dira. Ondoren, Aldagai bakoitzaren edukia eta memoriako helbidea pantailaratzen da.

Jakina denez int, float eta char datu-motak xeheak dira. Bestalde, badakigu array, karaktere-kate eta estruktura datu-motak egituratuak direla. Nabarmentzekoa da estruktura datu-mota egituratua izan arren, antzekotasun gehiago dituela int, float eta char datu-motak xeheekin arrayekin baino.

/* Ariketa-67_Helbideak: datu-mota desberdineko aldagaien helbideak
                         eta hasieratutako aldagaien edukiak. */

//   DEKLARAZIOA             EDUKIA           HELBIDEA
//   -----------             ------           --------
//   int iKopurua;           iKopurua         &iKopurua
//   float fNeurria;         fNeurria         &fNeurria
//   char cKarakterea;       cKarakterea      &cKarakterea
//   struct tstFitxa stNi    stNi.{eremu}     &stNi
//   char sIzena[21]         sIzena (%s)      sIzena (%d)
//   float afNotak[8]        afNotak[i]       afNotak

#include <stdio.h>

// Estrukturaren datu-mota definitzen,
// definizio orokorra programa osorako
struct tstIkaslea
{
  int iAdina;
  float fNota;
  char sNor[4];
};

int main()
{
    struct tstIkaslea stIkasleBat = {19, 7.5, "Ixa"};
    float afEuroak[3] = {19.5, 14.7, 21.8};
    char sIzena[4] = "Jon";
    char cLetra = 'W';
    float fZenbakiErreala = 8.3;
    int iZenbakiOsoa = -145;

    printf("\n \t========================================================");
    printf("\n \t Datu-mota desberdineko aldagaien helbideak eta edukiak");
    printf("\n \t========================================================\n");


    printf("\n \t -------------------------------");
    printf("\n \t cLetra=%c \t &cLetra=%d", cLetra, &cLetra);
    printf("\n \t -------------------------------");

    printf("\n \t ------------------------------------------------");
    printf("\n \t fZenbakiErreala=%.1f \t &fZenbakiErreala=%d", fZenbakiErreala, &fZenbakiErreala);
    printf("\n \t ------------------------------------------------");

    printf("\n \t ---------------------------------------------");
    printf("\n \t iZenbakiOsoa=%d \t &iZenbakiOsoa=%d", iZenbakiOsoa, &iZenbakiOsoa);
    printf("\n \t ---------------------------------------------");

    printf("\n \t ------------------------------------------");
    printf("\n \t sIzena(%%s)=%s", sIzena);
    printf("\n \t sIzena(%%d)=%d \t &sIzena[0]=%d", sIzena, &sIzena[0]);
    printf("\n \t sIzena[0]=%c \t\t &sIzena[0]=%d", sIzena[0], &sIzena[0]);
    printf("\n \t sIzena[1]=%c \t\t &sIzena[1]=%d", sIzena[1], &sIzena[1]);
    printf("\n \t sIzena[2]=%c \t\t &sIzena[2]=%d", sIzena[2], &sIzena[2]);
    printf("\n \t sIzena[3]=%c \t\t &sIzena[3]=%d", sIzena[3], &sIzena[3]);
    printf("\n \t ------------------------------------------");

    printf("\n \t ----------------------------------------------------");
    printf("\n \t &stIkasleBat=%d \t &stIkasleBat.iAdina= %d", &stIkasleBat, &stIkasleBat.iAdina);
    printf("\n \t stIkasleBat.iAdina=%d \t &stIkasleBat.iAdina= %d", stIkasleBat.iAdina, &stIkasleBat.iAdina);
    printf("\n \t stIkasleBat.fNota=%.1f \t &stIkasleBat.fNota=  %d", stIkasleBat.fNota, &stIkasleBat.fNota);
    printf("\n \t stIkasleBat.sNor=%s \t &stIkasleBat.sNor=   %d", stIkasleBat.sNor, &stIkasleBat.sNor);
    printf("\n \t stIkasleBat.sNor[0]=%c \t &stIkasleBat.sNor[0]=%d", stIkasleBat.sNor[0], &stIkasleBat.sNor[0]);
    printf("\n \t stIkasleBat.sNor[1]=%c \t &stIkasleBat.sNor[1]=%d", stIkasleBat.sNor[1], &stIkasleBat.sNor[1]);
    printf("\n \t stIkasleBat.sNor[2]=%c \t &stIkasleBat.sNor[2]=%d", stIkasleBat.sNor[2], &stIkasleBat.sNor[2]);
    printf("\n \t stIkasleBat.sNor[3]=%c \t &stIkasleBat.sNor[3]=%d", stIkasleBat.sNor[3], &stIkasleBat.sNor[3]);
    printf("\n \t ----------------------------------------------------");

    printf("\n \t --------------------------------------------");
    printf("\n \t afEuroak=%d \t &afEuroak[0]=%d", afEuroak, &afEuroak[0]);
    printf("\n \t afEuroak[0]=%.1f   \t &afEuroak[0]=%d", afEuroak[0], &afEuroak[0]);
    printf("\n \t afEuroak[1]=%.1f   \t &afEuroak[1]=%d", afEuroak[1], &afEuroak[1]);
    printf("\n \t afEuroak[2]=%.1f   \t &afEuroak[2]=%d", afEuroak[2], &afEuroak[2]);
    printf("\n \t --------------------------------------------");

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