| ZER DAKIDAN: Array datu-mota ezagutzen dut, eta kateak deritzen char datu-motako elementuen arrayak ezagutzen ditut ere. ZER IKASIKO DUDAN: Bi dimentsiotako karaktere-kateak ikasiko ditut eta karaktere-kateen arrayak ikasiko ditut. |
Arrayen arrayak
Zenbaki osoak gordeko dituen bi dimentsiotako array bat honelaxe deklaratzen da eta taulako elementu jakin bat atzitzeko aiZenbakiak[iIndize1][iIndize2] idatzi beharko da:
#define ERRENKADAK 6 #define ZUTABEAK 10 int aiZenbakiak[ERRENKADAK][ZUTABEAK]; // osoen taula bat
Modu beretsuan joka daiteke kateekin, adibidez 6 kate array batean bilduz. Honela:
#define ERRENKADAK 6 #define LUZERA_MAX 10 char acHitzak[ERRENKADAK][LUZERA_MAX]; // karakteren taula bat
Argi dago karaktere jakin bat erreferentziatzeko acHitzak[iIndize1][iIndize2] moldea erabili beharko litzatekeela, baina, eta hau oso interesgarria da, karaktere-taulako hitz jakin baten erreferentzia egin daiteke ere, adibidez acHitzak[0] lehen hitza litzateke. Honetaz sakontzeko bi programa hauek landuko ditugu Ariketa-51a_KateenArraya.cbp proiektua eta Ariketa-51b_KateenArraya.cbp proiektua, bi programa horiek ondo ulertzeko Ariketa-51c_KateenArraya.cbp eta Ariketa-51d_KateenArraya.cbp proiektuak garatu dira ere.
Lehen programa honetan informazio biltzeko, bi dimentsiotako char asZerrenda[ZENBAT_MAXIMOA][KATE_LUZERAMAX] karaktereen taula definitu eta hasieratu da. Hau da, karaktereen bi dimentsiotako taula edo kateen dimentsio bakarreko zerrenda.
/* Ariketa-51a_KateenArraya: zenbait kate array batean bildurik. */
// Teklatuz emandako hitz bat konparatzen du aurretik programak gorderik
// dituen hitz sorta batekin.
// Bi dimentsiotako array bat, arrayen array bat da. Beraz, kateen array
// bat karaktereen taula bat litzateke, non, errenkadak kateak liratekeen
// eta zutabeak karaktereak liratekeen.
#include <stdio.h>
#include <string.h> // strcmp() funtziorako
#define ZENBAT_MAXIMOA 6
#define KATE_LUZERAMAX 40
#define FALSE 0
#define TRUE 1
int main(void)
{
int iKont;
int iEmaitza;
int iBerdinakDira = FALSE; // hasieran FALSE, gero berdinak direla frogatzean TRUE
char sIzenBerria[KATE_LUZERAMAX];
static char asZerrenda[ZENBAT_MAXIMOA][KATE_LUZERAMAX] =
{
"Katalin",
"Danel",
"Noelia",
"Anabel",
"Jare",
"Izaro"
};
printf("\n");
printf("\n Letra xeheak eta letra larriak desberdintzen dira... ");
printf("\n Zure izena eman (adibidez, Danel edo Daniel): ");
gets(sIzenBerria);
for (iKont = 0; iKont < ZENBAT_MAXIMOA; iKont++)
{
// int strcmp(const char *kate1, const char *kate2);
iEmaitza = strcmp(asZerrenda[iKont], sIzenBerria); // iKont-garren katearen helbidea
if (iEmaitza > 0)
printf("\n %d ----- '%s' vs. '%s', zure izena txikiagoa da", iKont, sIzenBerria, asZerrenda[iKont]);
if (iEmaitza < 0)
printf("\n %d ----- '%s' vs. '%s', zure izena handiagoa da", iKont, sIzenBerria, asZerrenda[iKont]);
if (iEmaitza == 0)
{
printf("\n %d ----- '%s' vs. '%s' berdinak dira", iKont, sIzenBerria, asZerrenda[iKont]);
iBerdinakDira = TRUE;
}
}
if (iBerdinakDira == TRUE)
printf("\n\n '%s' zerrendan zaude, aurrera!", sIzenBerria);
else
printf("\n\n '%s' ez zaude zerrendan, ezin zara sartu!", sIzenBerria);
printf("\n");
getchar();
return 0;
}
Bigarren programa honetan aurreko informazio bera biltzeko, 6 kateei seinalatzen dieten 6 erakusleen char *Zerrenda[MAXIMOA] array lineala definitu da. Holako definizioak eskumatik ezkerrera interpretatzen dira, goazen urratsez urrats:
char * Zerrenda [ZENBAT_MAXIMOA] ---- --- -------- ---------------- 4 3 2 1
- [ZENBAT_MAXIMOA] array bat dela adierazte du, 6 elementuko array izango dela besterik ez dakigu
- Zerrenda arrayen izena, 6 elementuko Zerrenda delako array izango dela dakigu
- * erakusleen array bat, Zerrenda delako array 6 elementu izango ditu eta erakusleak (helbideak) izango dira
- char karaktereak dira erakusleen seinalatutakoak
Ondorioz, Zerrenda[1] arrayaren bigarren kateari seinalatzen dion erakuslea litzateke (adibidean Danel izena), edo, besterik gabe, arrayaren bigarren posizioko katea da Zerrenda[1]. Bestalde, Zerrenda[2][1] moldeak karaktere bat adierazten du, arrayaren hirugarren katearen bigarren karakterea (adibidean Noelia izenaren o letra).
/* Ariketa-51b_KateenArraya: kateei dagozkien erakusleak array batean bildurik. */
// Teklatuz emandako hitz bat konparatzen du aurretik programak gorderik
// dituen hitz sorta batekin.
// Bi dimentsiotako array bat, arrayen array bat da. Beraz, erakusleen array
// bat bi dimentsiotako taula bezala uler daiteke ere baldin eta erakusleek
// array batzuei (edo kate batzuei) seinalatzen badiete.
#include <stdio.h>
#include <string.h> // strcmp() funtziorako
#define ZENBAT_MAXIMOA 6
#define FALSE 0
#define TRUE 1
int main(void)
{
int iKont;
int iEmaitza;
int iBerdinakDira = FALSE; // hasieran FALSE, gero berdinak direla frogatzean TRUE
char sIzenBerria[ZENBAT_MAXIMOA];
static char *Zerrenda[ZENBAT_MAXIMOA] = // erakusleen array bat, erakusleek kateak seinalatzen dituzte
{
"Katalin",
"Danel",
"Noelia",
"Anabel",
"Jare",
"Izaro"
};
printf("\n");
printf("\n Letra larriak eta letra xeheak desberdintzen dira... ");
printf("\n Zure izena eman (adibidez, Izar edo Izaro): ");
gets(sIzenBerria);
for (iKont = 0; iKont < ZENBAT_MAXIMOA; iKont++)
{
// int strcmp(const char *kate1, const char *kate2);
iEmaitza = strcmp(Zerrenda[iKont], sIzenBerria); // iKont-garren erakuslea
if (iEmaitza > 0)
printf("\n %d ----- '%s' vs. '%s', zure izena txikiagoa da", iKont, sIzenBerria, Zerrenda[iKont]);
if (iEmaitza < 0)
printf("\n %d ----- '%s' vs. '%s', zure izena handiagoa da", iKont, sIzenBerria, Zerrenda[iKont]);
if (iEmaitza == 0)
{
printf("\n %d ----- '%s' vs. '%s' berdinak dira", iKont, sIzenBerria, Zerrenda[iKont]);
iBerdinakDira = TRUE;
}
}
if (iBerdinakDira == TRUE)
printf("\n\n '%s' zerrendan zaude, aurrera!", sIzenBerria);
else
printf("\n\n '%s' ez zaude zerrendan, ezin zara sartu!", sIzenBerria);
printf("\n");
getchar();
return 0;
}
Programa hau exekutatu eta ikusi memorian zer gordetzen den kasu batean zein bestean. Nabaria da, karaktereen taularen kasuan, kateak laburrak direnean memoriako posizio batzuk hutsik geratzen direla (erreserbatuta daude baina ez dira probesten). Erakusleen kasuan berriz, erakusleen arrayak bere espazioa eskatzen du (4 byte erakusle bakoitzeko, adibidean 6x4=24 byte), baina gero kate bakoitzaren tamaina doi-doi neurtuz ez du gehiegizko espaziorik hartzen:
/* Ariketa-51c_KateenArraya: zenbait kate arrayan bildurik kasua konparatzen
kateei dagozkien erakusleak arrayaren kasuarekin.*/
// asZerrenda konstantea hasieratuta eta Zerrenda konstantea hasieratuta,
// aztertu bakoitzaren edukia eta memorian hartutako lekua.
#include <stdio.h>
#include <string.h> // strlen() funtziorako
#define ZENBAT_MAXIMOA 6
#define KATE_LUZERAMAX 15 // 14 letra + null karaktere mugatzailea
int main(void)
{
int iKont;
int iKont_Kanpokoa;
int iKont_Barrukoa;
int iMetatua;
int iByteKop_KaraktereenTaula;
int iByteKop_ErakusleBat;
int iByteKop_ErakusleenArraya;
static char asZerrenda[ZENBAT_MAXIMOA][KATE_LUZERAMAX] = // kateen array bat
{
"katalin",
"danel",
"noelia",
"anabel",
"jare",
"izaro"
};
static char *Zerrenda[ZENBAT_MAXIMOA] = // erakusleen array bat, erakusleek kateak seinalatzen dituzte
{
"KATALIN",
"DANEL",
"NOELIA",
"ANABEL",
"JARE",
"IZARO"
};
printf("\n");
printf("\n KATE_LUZERAMAX = %d", KATE_LUZERAMAX);
printf("\n ZENBAT_MAXIMOA = %d", ZENBAT_MAXIMOA);
iByteKop_KaraktereenTaula = (int)sizeof(asZerrenda);
printf("\n iByteKop_KaraktereenTaula = %d byte ", iByteKop_KaraktereenTaula);
printf("\n");
for (iKont_Kanpokoa = 0; iKont_Kanpokoa < ZENBAT_MAXIMOA; iKont_Kanpokoa++)
{
for (iKont_Barrukoa = 0; iKont_Barrukoa < KATE_LUZERAMAX; iKont_Barrukoa++)
{
if (iKont_Barrukoa == strlen(asZerrenda[iKont_Kanpokoa]))
printf("\\0,");
if ((iKont_Barrukoa < strlen(asZerrenda[iKont_Kanpokoa])) &&
(iKont_Barrukoa != strlen(asZerrenda[iKont_Kanpokoa])))
printf(" %c,", asZerrenda[iKont_Kanpokoa][iKont_Barrukoa]);
if ((iKont_Barrukoa < KATE_LUZERAMAX-1) &&
(iKont_Barrukoa > strlen(asZerrenda[iKont_Kanpokoa])))
printf(" ,");
if (iKont_Barrukoa == KATE_LUZERAMAX-1)
printf(" .");
}
printf("\t%d byte \n", KATE_LUZERAMAX);
}
printf(" Karaktereen taula, guztira %dx%d=%d byte ", ZENBAT_MAXIMOA, KATE_LUZERAMAX, ZENBAT_MAXIMOA*KATE_LUZERAMAX);
printf("\n\n");
printf("\n ZENBAT_MAXIMOA = %d", ZENBAT_MAXIMOA);
iByteKop_ErakusleBat = (int)sizeof(*Zerrenda);
iByteKop_ErakusleenArraya = (int)sizeof(Zerrenda);
printf("\n iByteKop_ErakusleBat = %d byte ", iByteKop_ErakusleBat);
printf("\n iByteKop_ErakusleenArraya = %d byte ", iByteKop_ErakusleenArraya);
iMetatua = 0;
printf("\n Kateak diren erakutsien bytak: \n");
for (iKont = 0; iKont < ZENBAT_MAXIMOA; iKont++)
{
printf(" Zerrenda[%d][0] = %c %d+1 byte Zerrenda[%d] = %s\\0 \n", iKont, Zerrenda[iKont][0], strlen(Zerrenda[iKont]), iKont, Zerrenda[iKont]);
iMetatua = iMetatua + strlen(Zerrenda[iKont]) + 1;
}
printf(" Erakusleen arraya, guztira %d+%d=%d byte ", iByteKop_ErakusleenArraya, iMetatua, iByteKop_ErakusleenArraya+iMetatua);
printf("\n");
getchar();
return 0;
}
51c_KateenArraya.cbp proiektuan arreta jarri dugu karaktereen taularen edukian eta erakusleen arrayaren edukian. Jarraian ematen den 51d_KateenArraya.cbp programa honetan helbideak izango dira gure ikasgaia. Programa hau exekutatu eta ikusi memoria nola antolatzen den kasu batean zein bestean:
/* Ariketa-51d_KateenArraya: HELBIDEAK zenbait kate arrayan bildurik kasua konparatzen
kateei dagozkien erakusleak arrayaren kasuarekin.*/
// asZerrenda konstantea hasieratuta eta Zerrenda konstantea hasieratuta,
// helbideak aztertuz ulertu konstante bakoitzaren antolaketa memorian.
#include <stdio.h>
#include <string.h> // strlen() funtziorako
#define ZENBAT_MAXIMOA 4
#define KATE_LUZERAMAX 15 // 14 letra + null karaktere mugatzailea
int main(void)
{
static char asZerrenda[ZENBAT_MAXIMOA][KATE_LUZERAMAX] =
{
"katalin",
"danel",
"jare",
"izaro"
};
static char *Zerrenda[ZENBAT_MAXIMOA] = // erakusleen array bat, erakusleek kateak seinalatzen dituzte
{
"KATALIN",
"DANEL",
"JARE",
"IZARO"
};
printf("\n");
printf("\n 4x15 taularen helbideak");
printf("\n -----------------------");
printf("\n Karaktereen taula osoa: asZerrenda = %d", (int)asZerrenda);
printf("\n 1. katea: asZerrenda[0] = %d", (int)asZerrenda[0]);
printf("\n 1. kateko lehen karakterea: &asZerrenda[0][0] = %d", (int)&asZerrenda[0][0]);
printf("\n 1. kateko azken karakterea: &asZerrenda[0][14] = %d", (int)&asZerrenda[0][14]);
printf("\n 2. katea: asZerrenda[1] = %d", (int)asZerrenda[1]);
printf("\n 2. kateko lehen karakterea: &asZerrenda[1][0] = %d", (int)&asZerrenda[1][0]);
printf("\n 2. kateko azken karakterea: &asZerrenda[1][14] = %d", (int)&asZerrenda[1][14]);
printf("\n 3. katea: asZerrenda[2] = %d", (int)asZerrenda[2]);
printf("\n 3. kateko lehen karakterea: &asZerrenda[2][0] = %d", (int)&asZerrenda[2][0]);
printf("\n 3. kateko azken karakterea: &asZerrenda[2][14] = %d", (int)&asZerrenda[2][14]);
printf("\n 4. katea: asZerrenda[3] = %d", (int)asZerrenda[3]);
printf("\n 4. kateko lehen karakterea: &asZerrenda[3][0] = %d", (int)&asZerrenda[3][0]);
printf("\n 4. kateko azken karakterea: &asZerrenda[3][14] = %d", (int)&asZerrenda[3][14]);
printf("\n Taularen azken karakterea: &asZerrenda[3][14] = %d", (int)&asZerrenda[3][14]);
printf("\n");
printf("\n Erakusleen arrayaren helbideak");
printf("\n ------------------------------");
printf("\n Erakusleen array osoa: Zerrenda = %d", (int)Zerrenda);
printf("\n 1. erakuslearen helbidea: &Zerrenda[0] = %d", (int)&Zerrenda[0]);
printf("\n 2. erakuslearen helbidea: &Zerrenda[1] = %d", (int)&Zerrenda[1]);
printf("\n 3. erakuslearen helbidea: &Zerrenda[2] = %d", (int)&Zerrenda[2]);
printf("\n 4. erakuslearen helbidea: &Zerrenda[3] = %d", (int)&Zerrenda[3]);
printf("\n");
printf("\n Erakusleen edukiak (edo kateen helbideak)");
printf("\n -----------------------------------------");
printf("\n 1. erakuslearen edukia: Zerrenda[0] = %d (1. katearen helbidea)", (int)Zerrenda[0]);
printf("\n 2. erakuslearen edukia: Zerrenda[1] = %d (2. katearen helbidea)", (int)Zerrenda[1]);
printf("\n 3. erakuslearen edukia: Zerrenda[2] = %d (3. katearen helbidea)", (int)Zerrenda[2]);
printf("\n 4. erakuslearen edukia: Zerrenda[3] = %d (4. katearen helbidea)", (int)Zerrenda[3]);
printf("\n");
printf("\n Seinalatuak diren kateen edukiak");
printf("\n --------------------------------");
printf("\n 1. katearen eduki osoa: *Zerrenda = %s", *Zerrenda);
printf("\n 1. katearen lehen karakterea: *Zerrenda[0] = %c", *Zerrenda[0]);
printf("\n 1. katearen azken karakterea: *(Zerrenda[0]+strln()-1) = %c", *(Zerrenda[0]+strlen(*(Zerrenda))-1));
printf("\n 1. katearen KATE_LUZERAMAX: strlen(*Zerrenda) = %d", strlen(*Zerrenda));
printf("\n 2. katearen eduki osoa: *(Zerrenda+1) = %s", *(Zerrenda+1));
printf("\n 2. katearen lehen karakterea: *Zerrenda[1] = %c", *Zerrenda[1]);
printf("\n 2. katearen azken karakterea: *(Zerrenda[1]+strln()-1) = %c", *(Zerrenda[1]+strlen(*(Zerrenda+1))-1));
printf("\n 2. katearen KATE_LUZERAMAX: strlen(*(Zerrenda+1)) = %d", strlen(*(Zerrenda+1)));
printf("\n 3. katearen eduki osoa: *(Zerrenda+2) = %s", *(Zerrenda+2));
printf("\n 3. katearen lehen karakterea: *Zerrenda[2] = %c", *Zerrenda[2]);
printf("\n 3. katearen azken karakterea: *(Zerrenda[2]+strln()-1) = %c", *(Zerrenda[2]+strlen(*(Zerrenda+2))-1));
printf("\n 3. katearen KATE_LUZERAMAX: strlen(*(Zerrenda+2)) = %d", strlen(*(Zerrenda+2)));
printf("\n 4. katearen eduki osoa: *(Zerrenda+3) = %s", *(Zerrenda+3));
printf("\n 4. katearen lehen karakterea: *Zerrenda[3] = %c", *Zerrenda[3]);
printf("\n 4. katearen azken karakterea: *(Zerrenda[3]+strln()-1) = %c", *(Zerrenda[3]+strlen(*(Zerrenda+3))-1));
printf("\n 4. katearen KATE_LUZERAMAX: strlen(*(Zerrenda+3)) = %d", strlen(*(Zerrenda+3)));
printf("\n");
getchar();
return 0;
}
|
iruzkinik ez:
Argitaratu iruzkina