ZER DAKIDAN: Arrayak eta erregistroak ezagutzen ditut.
ZER IKASIKO DUDAN: Ordenaturik dagoen erregistroen array batetik abiatuta, dagokion array desordenatu bat lortu informazioa galdu edo nahastu gabe.
kaosa sortzen
Erregistroen array bat daukagu. Erregistroak bi eremuz osaturik daude: kate bat eta zenbaki bat. Erregistroen arrayaren datuak konstante diren bi arrayetatik hartzen dira. Erregistroen arrayaren datu-mota:
asIZENAK array konstantea eta ordenatua da, afNOTAK array konstantea da. Bi array horietaz oinarriturik balioak hartuko ditu ardIkasleak arrayak zein alfabetikoki ordenaturik egongo den ere. ardIkasleak array ordenatuaren elementuak posizioz nahastuz lortuko da emaitza den ardKaotikoak arraya.
Nahasketa burutzen duen ZerrendaNahastu prozeduran datu-mota berezi pare bat sortuko dugu, trdLaguntzaile erregistroa eta tardLaguntzaile arraya. Programaren gainerako tokietan erabilpenik ez dutenez, datu-mota espezifiko horiek ZerrendaNahastu prozedura barruan sortzen dira:
// datu-mota berri sortzen da, soilik ZerrendaNahastu() delako
// funtzio honetan erabiliko dena: trdLaguntzaile erregistroa
void ZerrendaNahastu(const tardIkasleak ardIkasleak, int iLuzera, tardIkasleak ardKaotikoak)
{
typedef struct
{
trdIkasle rdIkaslea;
bool boGordeta;
} trdLaguntzaile; // erregistro datu-mota berria
trdLaguntzaile ardLaguntzailea[IZENBATIKASLE]; // erregistro datu-mota berriko arraya
...
}
/* Ariketa-73_KaosaSortzenArrayBatean: ordenaturik dagoen erregistroen array batetik
array desordenatu bat lortu informazioa galdu
edo nahastu gabe. */
// Hasierako informazioa erregistroen bektore bat da, non izenak eta notak gordetzen
// diren. Bektorea izenen arabera alfabetikoki sailkaturik dago. Array laguntzaile
// baten bitartez jatorrizko bektorea desordenatu behar da, hori bai, mantenduz
// elkarrekin ikaslearen izena eta berari dagokion nota.
#include <stdio.h>
#include <string.h> // strcpy() funtziorako
#include <stdlib.h> // srand() eta rand() funtzioetarako
#include <time.h> // time() funtziorako
#include <stdbool.h> // bool datu-motarako
#define IZENBATIKASLE 12
typedef char tsKate49[50]; // 49 karaktere gehi null mugatzailea
typedef struct
{
tsKate49 sNor;
float fNota;
} trdIkasle;
typedef trdIkasle tardIkasleak[IZENBATIKASLE];
const tsKate49 asIZENAK[IZENBATIKASLE] = {
"AGIRRE ROMERO, UNAI", // 00
"ANGULEMA CARAZO, JON ANDER", // 01
"BIKARREGI IGLESIAS, JULEN", // 02
"CANO RUIZ DE HEREDIA, JULIAN", // 03
"CORRAL EGIA, JOSEBA ANDONI", // 04
"DIAZ DE ULZURRUN, ROY, LEONOR", // 05
"EGIGUREN MARKINEZ, IRUNE", // 06
"ERKIAGA ANDONEGI, IKER", // 07
"FERNANDEZ FEITO, FELIX", // 08
"GARTZIA DE ALZA GIL, KATALIN", // 19
"HERRANZ MARTINEZ, REBECA", // 10
"IRAGORRI COTANO, MARTIN" // 11
};
const float afNotaK[IZENBATIKASLE] = {4.6, 3.2, 5.7, 4.8, 5.1, 6.1, 7.3, 7.6, 2.8, 9.2, 2.9, 8.5};
void DatuakBildu(tardIkasleak ardIkasleak, int iLuzera);
void DatuakIkusi(const tardIkasleak ardIkasleak, int iLuzera);
void ZerrendaNahastu(const tardIkasleak ardIkasleak,
int iLuzera,
tardIkasleak ardKaotikoak);
int main()
{
tardIkasleak ardIkasleak;
tardIkasleak ardKaotikoak;
int iLuzera;
printf("\n");
do
{
printf("Zenbat ikasle dira? (1 eta %d artean): ", IZENBATIKASLE);
scanf("%d", &iLuzera);
fflush(stdin);
} while (iLuzera < 1 || iLuzera > IZENBATIKASLE);
DatuakBildu(ardIkasleak, iLuzera);
printf("\n--Nahastu aurretik----------------------------------------------------------\n");
DatuakIkusi(ardIkasleak, iLuzera);
ZerrendaNahastu(ardIkasleak, iLuzera, ardKaotikoak);
printf("\n--Nahastu ondoren-----------------------------------------------------------\n");
DatuakIkusi(ardKaotikoak, iLuzera);
printf("\n");
return 0;
}
void DatuakBildu(tardIkasleak ardIkasleak, int iLuzera)
{
for (int k = 0; k < iLuzera; k++)
{
strcpy(ardIkasleak[k].sNor, asIZENAK[k]);
ardIkasleak[k].fNota = afNotaK[k];
}
}
void DatuakIkusi(const tardIkasleak ardIkasleak, int iLuzera)
{
for (int k = 0; k < iLuzera; k++)
{
printf("%2d. ikaslea: %-40s%10.1f\n", k+1, ardIkasleak[k].sNor, ardIkasleak[k].fNota);
}
}
// datu-mota berri sortzen da, soilik ZerrendaNahastu() delako
// funtzio honetan erabiliko dena: trdLaguntzaile erregistroa
void ZerrendaNahastu(const tardIkasleak ardIkasleak, int iLuzera, tardIkasleak ardKaotikoak)
{
typedef struct
{
trdIkasle rdIkaslea;
bool boGordeta;
} trdLaguntzaile; // erregistro datu-mota berria
trdLaguntzaile ardLaguntzailea[IZENBATIKASLE]; // erregistro datu-mota berriko arraya
for (int k = 0; k < iLuzera; k++)
{
ardLaguntzailea[k].boGordeta = false;
}
srand(time(NULL));
for (int k = 0; k < iLuzera; k++)
{
int iZbk;
do
{
iZbk = rand() % iLuzera;
} while (ardLaguntzailea[iZbk].boGordeta == true);
ardLaguntzailea[iZbk].boGordeta = true;
ardLaguntzailea[iZbk].rdIkaslea = ardIkasleak[k];
}
for (int k = 0; k < iLuzera; k++)
{
ardKaotikoak[k] = ardLaguntzailea[k].rdIkaslea;
}
}
ZER DAKIDAN: Arrayak eta erregistroak ezagutzen ditut.
ZER IKASIKO DUDAN: Kateen bi arrayetatik abiatuta erregistroen array bat lortuko dut programa honetan.
Elementuak ezabatu bi algoritmo desberdinez
Ikasleen informazioa biltzen duen bektore bat daukagu. Ikasle bakoitzaren informazioa izena eta adina dira.
Ikasleen izenak ez dira errepikatu behar eta horregatik BektoreaDatuDesberdinezBete() funtzioak iIkasleaBilatu() funtzioa darabil konprobatzeko onartuko duen ikaslea benetan berria den.
Bektorea datuz horniturik dagoenen bi ezabaketa egiten dira:
Ikasle baten izenaren hasiera A bada, ikasle hori zerrendatik kenduko da (ez da array laguntzailerik erabiltzen)
Ikasle bat gaztea denean, bere adina mediatik behera dagoelako, ikasle hori zerrendatik kenduko da (array laguntzaile bat erabiltzen da)
Bukatu aurretik ikasle berri baten datuak zerrendara eramaten dira. Lehenik tokirik dagoela konprobatzen da, gero ikasle berriaren posizioa zein den eskatzen da eta, azkenean, ikasle berriaren datuak jaso ondoren, erregistro hori dagokion posizioan zerrendan txertatzen da (desberdinduz benetako txertaketa den ala gehiketa den).
/* Ariketa-72_ArrayBatetikElementuakKendu: erregistroen array bat datuz bete ondoren
zenbait baldintza betetzen duten elementuak
arraytik kendu. */
// Hasierako informazioa erregistroen bektore bat da. Lehen ezabaketa A letratik
// hasten diren izenen elementuena da. Bigarren ezabaketa adin txikikoen elementuena
// da. Gero, amaitzeko, elementu berri baten txertaketa/gehiketa egiten da.
#include <stdio.h>
#include <string.h> // memcpy(), strcasecmp(), strcspn() eta strcpy() funtzioetarako
#include <ctype.h> // tolower() funtziorako
#define BEHEMUGA 0
#define GOIMUGA 24
#define LUZERAMAX 15+1
typedef char tsKate16[LUZERAMAX];
typedef struct
{
char sIzena[LUZERAMAX];
int iAdina;
} trdIkaslea;
typedef trdIkaslea tardZerrenda[GOIMUGA];
int iIkasleaBilatu(const tardZerrenda ardIkasgela,
int iLuzera,
const tsKate16 sGakoa);
void BektoreaDatuDesberdinezBete(tardZerrenda ardIkasgela, int* iLuzera);
void BektorearenEdukiaIkusi(const tardZerrenda ardIkasgela, int iLuzera);
void ElementuBatEzabatu(tardZerrenda ardIkasgela,
int* iLuzera,
int k);
int boIzenarenHasiera_A_Da(const trdIkaslea* rdIkasleBat);
float rBatezbestekoaKalkulatu(const tardZerrenda ardIkasgela, int iLuzera);
void IkasleGazteakEzabatu(tardZerrenda ardIkasgela,
int* iLuzera,
float rBatezBestekoa);
void IkasleBatenDatuakJaso(trdIkaslea* rdIkasleBat);
void IkasleBatTxertatu(tardZerrenda ardIkasgela,
int* iLuzera,
const trdIkaslea* rdIkaslea,
int iNon);
int main()
{
tardZerrenda ardIkasgela;
int iLuzera, k;
float rBatezBestekoa;
int iNon;
trdIkaslea rdIkasleBerria;
printf("------------------------------------------------\n\n");
BektoreaDatuDesberdinezBete(ardIkasgela, &iLuzera);
printf("\n");
BektorearenEdukiaIkusi(ardIkasgela, iLuzera);
k = BEHEMUGA;
while (k < iLuzera)
{
if (boIzenarenHasiera_A_Da(&ardIkasgela[k]))
ElementuBatEzabatu(ardIkasgela, &iLuzera, k);
else
k++;
}
printf("\nIzenaren hasiera A denean ikasleak zerrendatik kendu ostean:\n");
BektorearenEdukiaIkusi(ardIkasgela, iLuzera);
printf("\n");
rBatezBestekoa = rBatezbestekoaKalkulatu(ardIkasgela, iLuzera);
printf("BatezBestekoa = %.3f\n", rBatezBestekoa);
IkasleGazteakEzabatu(ardIkasgela, &iLuzera, rBatezBestekoa);
printf("Mediatik beherako adina duten ikasleak zerrendatik kendu ostean:\n");
BektorearenEdukiaIkusi(ardIkasgela, iLuzera);
printf("\nIkasle berri baten datuak zerrendan gorde:\n");
if (iLuzera < GOIMUGA)
{
do
{
printf("Eman ikasle berriaren posizioa zerrendan (%d eta %d) artekoa: ", BEHEMUGA, iLuzera);
scanf("%d", &iNon);
fflush(stdin);
} while (iNon < BEHEMUGA || iNon > iLuzera);
IkasleBatenDatuakJaso(&rdIkasleBerria);
if (iNon == iLuzera)
{
ardIkasgela[iNon] = rdIkasleBerria;
iLuzera++;
}
else
IkasleBatTxertatu(ardIkasgela, &iLuzera, &rdIkasleBerria, iNon);
BektorearenEdukiaIkusi(ardIkasgela, iLuzera);
}
else
printf("Zerrenda beterik dago, ezin da ikasle berririk sartu.\n");
printf("\n\nAmaituta!----------------------------------------\n\n");
return 0;
}
int iIkasleaBilatu(const tardZerrenda ardIkasgela,
int iLuzera,
const tsKate16 sGakoa)
{
int k = BEHEMUGA;
int boAurkitua = 0;
while (k <= iLuzera && !boAurkitua)
{
// strcasecmp() funtzioa strcmp() bezalakoa baina majuskulak eta minuskulak kontutan hartu gabe,
// konparaketa hasi baino lehen letra guztiak minuskuletan jartzen ditu funtzioak berak
if (strcasecmp(ardIkasgela[k].sIzena, sGakoa) == 0)
boAurkitua = 1;
else
k++;
}
return boAurkitua ? k : -1;
}
void BektoreaDatuDesberdinezBete(tardZerrenda ardIkasgela, int* iLuzera)
{
int k, iPosizioa;
char sNor[LUZERAMAX];
do
{
printf("Ikasleen kopurua eman: ");
scanf("%d", iLuzera);
fflush(stdin);
} while (*iLuzera < BEHEMUGA || *iLuzera > GOIMUGA);
printf("\nLehen ikaslearen izena berria delako ez dago errepikaturik...\n\n");
printf("Eman %d. ikaslearen izena: ", BEHEMUGA);
fgets(ardIkasgela[BEHEMUGA].sIzena, LUZERAMAX, stdin);
ardIkasgela[BEHEMUGA].sIzena[strcspn(ardIkasgela[BEHEMUGA].sIzena, "\n")] = 0; // lerro-berri karakterea kendu
printf("Eman %d. ikaslearen adina: ", BEHEMUGA);
scanf("%d", &ardIkasgela[BEHEMUGA].iAdina);
fflush(stdin);
printf("\nGainerako ikaslen izenak ez dira errepikatzen...\n\n");
for (k = BEHEMUGA + 1; k < *iLuzera; k++)
{
do
{
printf("Eman %d. ikaslearen izena: ", k);
fgets(sNor, LUZERAMAX, stdin);
sNor[strcspn(sNor, "\n")] = 0; // lerro-berri karakterea kendu
iPosizioa = iIkasleaBilatu(ardIkasgela, k - 1, sNor);
if (iPosizioa != -1)
printf("\"%s\" izeneko ikaslerik badago %d. posizioan\n", sNor, iPosizioa);
} while (iPosizioa != -1);
strcpy(ardIkasgela[k].sIzena, sNor);
printf("Eman %d. ikaslearen adina: ", k);
scanf("%d", &ardIkasgela[k].iAdina);
fflush(stdin);
printf("\n");
}
}
void BektorearenEdukiaIkusi(const tardZerrenda ardIkasgela, int iLuzera)
{
for (int k = BEHEMUGA; k < iLuzera; k++)
{
printf("%d. ikaslea: %-15s%20d urte\n", k, ardIkasgela[k].sIzena, ardIkasgela[k].iAdina);
}
}
void ElementuBatEzabatu(tardZerrenda ardIkasgela,
int* iLuzera,
int k)
{
for (int i = k; i < *iLuzera; i++)
{
ardIkasgela[i] = ardIkasgela[i + 1];
}
(*iLuzera)--;
}
int boIzenarenHasiera_A_Da(const trdIkaslea* rdIkasleBat)
{
return tolower(rdIkasleBat->sIzena[0]) == 'a';
}
float rBatezbestekoaKalkulatu(const tardZerrenda ardIkasgela, int iLuzera)
{
float rMetagailua = 0.0;
for (int k = BEHEMUGA; k < iLuzera; k++)
{
rMetagailua += ardIkasgela[k].iAdina;
}
return rMetagailua / iLuzera;
}
void IkasleGazteakEzabatu(tardZerrenda ardIkasgela,
int* iLuzera,
float rBatezBestekoa)
{
tardZerrenda ardLaguntzailea;
int iZenbatIkasle = 0;
for (int k = BEHEMUGA; k < *iLuzera; k++)
{
if (ardIkasgela[k].iAdina >= rBatezBestekoa)
{
ardLaguntzailea[iZenbatIkasle] = ardIkasgela[k];
iZenbatIkasle++;
}
}
memcpy(ardIkasgela, ardLaguntzailea, iZenbatIkasle*sizeof(trdIkaslea));
*iLuzera = iZenbatIkasle;
}
void IkasleBatenDatuakJaso(trdIkaslea* rdIkasleBat)
{
printf("Eman ikaslearen izena: ");
fgets(rdIkasleBat->sIzena, LUZERAMAX, stdin);
rdIkasleBat->sIzena[strcspn(rdIkasleBat->sIzena, "\n")] = 0; // lerro-berri karakterea kendu
printf("Eman ikaslearen adina: ");
scanf("%d", &rdIkasleBat->iAdina);
fflush(stdin);
}
void IkasleBatTxertatu(tardZerrenda ardIkasgela,
int* iLuzera,
const trdIkaslea* rdIkaslea,
int iNon)
{
for (int k = *iLuzera; k >= iNon; k--)
{
ardIkasgela[k + 1] = ardIkasgela[k];
}
ardIkasgela[iNon] = *rdIkaslea;
(*iLuzera)++;
}
}
ZER DAKIDAN: Arrayak eta estrukturak ezagutzen ditut.
ZER IKASIKO DUDAN: Kateen array batetik abiatuta, estrukturen array bat lortuko dut programa honetan.
Laborategiko gela batean, gehienez, 25 ikasle izango dira. Ikasleen datuak bektore batean biltzen dira, adibidez irudiko hurrengo 5 ikasleren datuak. Bektorearen elementuak kateak izanik bertan izena eta zenbaki bat daude koma batez banaturik. Jatorrizko kateak moztuz, beste array bat lortu behar da, 5 elementukoa ere, baina array berriaren elementuak estrukturak izango dira:
Horretarako, ezinbestekoa da datu-motak era egokian definitzea. Ondoko irudian erakusten da programatzaile batek egindako datu-mota definizioa:
Eta hauek dira aldagai garrantzitsuenak, kateen arraya eta estrukturen arraya:
/* Ariketa-70_EstrukturenBektoreBatLortu: kateen array batetik estrukturen array batera */
#include <stdio.h>
#include <string.h> // strcspn(), strchr(), strcpy(), strncpy() eta strcmp() funtzioetarako
#include <stdlib.h> // srand() eta rand() funtzioterako
#include <time.h> // time() funtziorako
#include <ctype.h> // toupper() funtziorako
#include <conio.h> // getche() funtziorako
#include <math.h> // fabs() funtziorako
#define IKASLE_KOP_MAX 25
#define KATEEN_LUZ_MAX 31
struct tstElementu
{
char sNor[31];
float fNota;
};
void DatuakSartu(char asZerrenda_1[IKASLE_KOP_MAX][KATEEN_LUZ_MAX],
int *iLuzera);
void DatuakIkusi(const char asZerrenda_1[IKASLE_KOP_MAX][KATEEN_LUZ_MAX],
int iLuzera);
int iElementuaBilatu(const char asZerrenda_1[IKASLE_KOP_MAX][KATEEN_LUZ_MAX],
int iLuzera,
const char sGakoDatuOsoa[31]);
void IzenaZenbakiaBanatu( char *sDatua,
char sIzena[31],
float *fZbk);
void BektoreBerriaSortu( char asZerrenda_1[IKASLE_KOP_MAX][KATEEN_LUZ_MAX],
struct tstElementu astZerrenda_2[IKASLE_KOP_MAX],
int iLuzera);
void BektoreBerriaIkusi(const struct tstElementu astZerrenda_2[IKASLE_KOP_MAX],
int iLuzera);
int iIkasleaIzenezBilatu(const struct tstElementu astZerrenda_2[IKASLE_KOP_MAX],
int iLuzera,
const char sGakoa[31]);
int iIkasleaNotazBilatu(const struct tstElementu astZerrenda_2[IKASLE_KOP_MAX],
int iLuzera,
float fGakoa);
int main()
{
char asZerrenda_1[IKASLE_KOP_MAX][KATEEN_LUZ_MAX];
struct tstElementu astZerrenda_2[IKASLE_KOP_MAX]; // gehienez 25 ikasle, indizeak 0-tik 24-ra
int iLuzera, iNon;
char sGakoa[KATEEN_LUZ_MAX];
float fGakoa;
DatuakSartu(asZerrenda_1, &iLuzera);
printf("\n");
DatuakIkusi(asZerrenda_1, iLuzera);
printf("Ikaslearen datuak eman (adibidez 'Jokin,+1.38')\nelementu horren posizioa zehazteko: ");
gets(sGakoa);
iNon = iElementuaBilatu(asZerrenda_1, iLuzera, sGakoa);
if (iNon == -1)
printf("'%s' elementu hori ez dago gelan\n", sGakoa);
else
printf("'%s' elementuaren posizioa gelan %d da\n", sGakoa, iNon);
printf("\n\n");
BektoreBerriaSortu(asZerrenda_1, astZerrenda_2, iLuzera);
BektoreBerriaIkusi(astZerrenda_2, iLuzera);
printf("Ikaslearen izena eman (adibidez 'Jokin')\nbere posizioa zehazteko: ");
gets(sGakoa);
iNon = iIkasleaIzenezBilatu(astZerrenda_2, iLuzera, sGakoa);
if (iNon == -1)
printf("'%s' izeneko ikaslerik ez dago gelan\n", sGakoa);
else
printf("'%s' ikaslearen posizioa gelan %d da\n", sGakoa, iNon);
printf("Ikaslearen nota eman bere posizioa zehazteko: ");
scanf("%f", &fGakoa);
iNon = iIkasleaNotazBilatu(astZerrenda_2, iLuzera, fGakoa);
if (iNon == -1)
printf("%.2f nota duen ikaslerik ez dago gelan\n", fGakoa);
else
printf("%.2f nota duen ikaslearen posizioa gelan %d da\n", fGakoa, iNon);
printf("\n");
getchar();
return 0;
}
void DatuakSartu(char asZerrenda_1[IKASLE_KOP_MAX][KATEEN_LUZ_MAX],
int *iLuzera)
{
int iKont = 0;
char cErantz;
char sIzena[KATEEN_LUZ_MAX];
char sZeinua[2] = "";
char sZbk[5] = "";
srand(time(NULL));
cErantz = 'B';
while (iKont < IKASLE_KOP_MAX && cErantz == 'B')
{
strcpy(asZerrenda_1[iKont], "");
printf("\n\nasZerrenda_1[%d]=|%s| (hasieran hutisk)", iKont, asZerrenda_1[iKont]);
printf("\n%d posizioko ikaslearen izena eman (adibidez, Danel): ", iKont);
gets(sIzena);
strcat(asZerrenda_1[iKont], sIzena);
strcat(asZerrenda_1[iKont], ",");
printf("asZerrenda_1[%d]=|%s| (izena,)", iKont, asZerrenda_1[iKont]);
if (rand() % 2 == 0)
sZeinua[0] = '-';
else
sZeinua[0] = '+';
strcat(asZerrenda_1[iKont], sZeinua);
printf("\nasZerrenda_1[%d]=|%s| (izena,+)izena,-)", iKont, asZerrenda_1[iKont]);
srand(time(NULL));
sZbk[0] = (char)(rand()%10 + (int)'0');
sZbk[1] = '.';
sZbk[2] = (char)(rand()%10 + (int)'0');
sZbk[3] = (char)(rand()%10 + (int)'0');
// printf("\nsZbk=|%s|\n\n", sZbk);
strcat(asZerrenda_1[iKont], sZbk);
printf("\nasZerrenda_1[%d]=|%s| (izena,+1.23)\n", iKont, asZerrenda_1[iKont]);
iKont++;
do
{
printf("Ikasle gehiagorik? (B/E): ");
cErantz = getche();
cErantz = toupper(cErantz);
if (cErantz != 'B' && cErantz != 'E')
printf("\n'B' ala 'E'\n");
} while (cErantz != 'B' && cErantz != 'E');
}
*iLuzera = iKont;
}
void DatuakIkusi(const char asZerrenda_1[IKASLE_KOP_MAX][KATEEN_LUZ_MAX],
int iLuzera)
{
printf("\nEdukiak:\n");
for (int i = 0; i < iLuzera; i++)
{
printf("%2d. ikaslea: %s\n", i + 1, asZerrenda_1[i]);
}
}
int iElementuaBilatu(const char asZerrenda_1[IKASLE_KOP_MAX][KATEEN_LUZ_MAX],
int iLuzera,
const char sGakoDatuOsoa[])
{
for (int iKont = 0; iKont < iLuzera; iKont++)
{
if (strcmp(asZerrenda_1[iKont], sGakoDatuOsoa) == 0)
return iKont;
}
return -1; // aurkitzen ez denean
}
void IzenaZenbakiaBanatu( char *sDatua,
char sIzena[31],
float *fZbk)
{
char *KomaErak;
char sLaguntzaile[KATEEN_LUZ_MAX];
printf("--------------------------------------------------\n");
printf(" ---sDatua=|%s|---\n", sDatua);
KomaErak = strchr(sDatua, ',');
printf("\n ---KomaErak=|%s|---\n", KomaErak);
printf("\n ___(helbidea) sDatua=%li___", (long)sDatua);
printf("\n ___(helbidea) KomaErak=%li___", (long)KomaErak);
printf("\n ___KomaErak - sDatua=%li (karaktere kopurua)___\n", (long)(KomaErak - sDatua));
if (KomaErak != NULL)
{
strncpy(sIzena, sDatua, KomaErak - sDatua);
sIzena[KomaErak - sDatua] = '\0';
printf("\n ---sIzena=|%s|---\n", sIzena);
printf("\n ---KomaErak=|%s|---", KomaErak);
printf("\n ---KomaErak+1=|%s|---", KomaErak+1);
printf("\n ---KomaErak-1=|%s|---", KomaErak-1);
strcpy(sLaguntzaile, KomaErak + 1);
*fZbk = atof(sLaguntzaile);
}
printf("\n--------------------------------------------------\n\n");
}
void BektoreBerriaSortu( char asZerrenda_1[IKASLE_KOP_MAX][KATEEN_LUZ_MAX],
struct tstElementu astZerrenda_2[IKASLE_KOP_MAX],
int iLuzera)
{
for (int i = 0; i < iLuzera; i++)
{
IzenaZenbakiaBanatu(asZerrenda_1[i], astZerrenda_2[i].sNor, &astZerrenda_2[i].fNota);
}
}
void BektoreBerriaIkusi(const struct tstElementu astZerrenda_2[IKASLE_KOP_MAX],
int iLuzera)
{
for (int i = 0; i < iLuzera; i++)
{
printf("%2d. ikaslea:\n", i + 1);
printf("Izena = %s\n", astZerrenda_2[i].sNor);
printf("Nota = %.2f\n\n", astZerrenda_2[i].fNota);
}
}
int iIkasleaIzenezBilatu(const struct tstElementu astZerrenda_2[IKASLE_KOP_MAX],
int iLuzera,
const char sGakoa[31])
{
for (int iKont = 0; iKont < iLuzera; iKont++)
{
if (strcmp(astZerrenda_2[iKont].sNor, sGakoa) == 0)
return iKont;
}
return -1; // aurkitzen ez denean
}
int iIkasleaNotazBilatu(const struct tstElementu astZerrenda_2[IKASLE_KOP_MAX],
int iLuzera,
float fGakoa)
{
#define DOITASUNA 0.0001
int iKont;
for (iKont = 0; iKont < iLuzera; iKont++)
{
if (fabs(astZerrenda_2[iKont].fNota - fGakoa) < DOITASUNA)
return iKont;
}
return -1; // aurkitzen ez denean
}
ZER IKASIKO DUDAN: Funtzionalitate bera duen programa idatziko dut baina erregistroen array bat erabiliz.
Galbahe (edo bahe) baten irudia. Galbaheri esker aleak sailka daitezkeen bezala, zenbaki zerrenda bati galbahe logikoren bat aplikatuz zenbakien segida desberdinak lor daitezke, adibidez: zenbaki lehenak identifikatzeko Eratostenes matematikari greziarrak asmatutakoa
Ariketa 69 | Eratostenes-en bahea (II) zenbaki osoen bi dimentsiotako array bat erabiliz
Eratostenes (antzinako grezieraz: Ἐρατοσθένης; K.a. 276 inguru - K.a. 195 inguru) matematikari, geografo, kirolari, poeta eta astronomo greziarra izan zen. Alexandriako Liburutegia famatuaren zuzendari izendatu zuten eta aurkikuntza ugari egin zituen, hala nola, latitude eta longitude sistema. Eratostenes ezaguna da Lurraren zirkunferentzia kalkulatzen lehen greziarra izan zelako, baita Lurraren ardatzak duen makurdura. Bestalde, garaiko ezagutza geografikoaren araberako mundu mapa eratu zuen ere.
Eratostenes-en bahea zenbaki lehenak aurkitzeko algoritmo bat da, emandako n zenbaki arrunt bat baino txikiagoak direnen artean.
Lehendabizi, taula bat egiten da 2 eta n arteko zenbaki arruntekin, jarraian multiploak markatzen dira hurrengo ordena jarraituz:
2tik hasita, haren multiplo guztiak markatzen dira, ostean, hurrengo zenbakiarekin jarraituko da baina bi egoera daude:
Hurrengo zenbakia markaturik gabe dago, adibidez 3 zenbakia, eta lehen bezala bere multiplo guztiak markatzen dira
Hurrengo zenbakia markaturik dago, adibidez 4 zenbakia, kasu honetan ez da ezer markatzen eta bere hurrengo zenbakia hartzen da
5ekin markatu beharko litzateke (goiko lehen kasua), 6kin ez litzateke ezer markatuko (goiko bigarren kasua), 7ekin markatu beharko litzateke (goiko lehen kasua), 8, 9 eta 10ekin ez litzateke ezer markatuko (goiko bigarren kasuak), e.a.
Prozedura errepikatzen da hau betetzen den bitartean: (MarkatuGabekoZenbakia)2<n. Beste modu batez esanik, markatu gabeko zenbakiaren karratua n baino handiagoa denean eten prozesu errepikakorra
Eratostenes-en bahearen animazioa 120 baino gutxiagoko zenbaki lehenentzat:
Hona hemen datu-taularen irudia MAX konstanteak 21 balio duenean, non 0 markak zenbaki lehen adierazten duen eta 1 markak zenbaki zatigarri adierazten duen:
0
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
zenbakia
1
0
0
1
0
1
0
1
1
1
0
1
0
1
1
1
0
1
0
1
1
marka
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
Programa honetan taularen 0 posizioa eta 1 posizioa ez dira erabiltzen datuak gordetzeko. Horregatik, goiko eskeman bi posizio horiek ez dira erakustsi.
/* Ariketa-69_EratostenesenBahea-2 */
/*
Muga den kopuru arrunta emanez, muga hori baino txikiagoak diren
"Zenbaki Lehenak" lortzeko metodo bat aurkitu zuen Eratostenesek.
Algoritmoa:
----------
2tik iMuga-rako zenbakiak zerrenda batean jartzen dira. Lehenengo, 2ren
multiplo guztiak markatzen dira, eta 2 zenbakia emaitza den lehenen
zerrendari gehituko zaio. Ondoren, 3ren multiplo guztiak markatuko dira,
eta 3 zenbakia gehituko zaio lehenen zerrendari. Gero, 4ari begiratzen
zaio, markatuta dagoela ikusten da, eta horrek esan nahi du 2rekin
zatigarria dela, eta, beraz, ez da lehena. Ondoren, 5era iristen da;
markatuta ez dagoenez, lehena da, bere multiplo guztiak markatzen dira
eta lehenen zerrendara gehituko da.
Prozesu errepikakorra bukatzeko baldintza: Une jakin batean aztertuko den
zenbakiaren karratua iMuga-tik beherakoa bada, jarraitu beharra dago.
Bestela, algoritmoa amaitu egiten da, eta markatu gabe geratu diren
guztiak zenbaki lehenak dira (emaitza-zerrendari gehitu beharrekoak).
Animazio hau ikusi:
https://upload.wikimedia.org/wikipedia/commons/b/b9/Sieve_of_Eratosthenes_animation.gif
Bi programa hauek aztertu:
* Ariketa-63_EratostenesenBahea-1 zenbaki osoen bi dimentsiotako arraya
* Ariketa-69_EratostenesenBahea_2 erregistroen dimentsio bakarreko arraya
*/
#include <stdio.h>
#include <stdbool.h> // bool datu-motarako
#define MAX 120
typedef struct
{
int iKopurua;
bool boMarkatua;
} trdDatua;
typedef trdDatua tardZenbakiak[MAX];
typedef int taiLehenak[MAX];
// Datuak hasieratzen ditu
void DatuakLortu(tardZenbakiak ardDatuak, int *iLuzeraDatuak);
// Zenbakiak ikusten ditu eta markatu gabeko lehenen kopurua kalkulatzen du
void ZenbakiakIkusi(const tardZenbakiak ardDatuak, int iLuzeraDatuak);
// Lehen zenbakiak lortzen ditu
void LehenakLortu(const tardZenbakiak ardDatuak, int iLuzeraDatuak, taiLehenak aiLehenak, int *iLuzeraLehenak);
// Lehen zenbakien zerrenda erakusten du
void LehenakIkusi(const taiLehenak aiLehenak, int iLuzeraLehenak);
// Programa nagusia
int main()
{
tardZenbakiak ardDatuak;
int iLuzeraDatuak;
taiLehenak aiLehenak;
int iLuzeraLehenak;
int iIterazioa = 2;
DatuakLortu(ardDatuak, &iLuzeraDatuak);
printf("Hasierako datuak:\n");
ZenbakiakIkusi(ardDatuak, iLuzeraDatuak);
printf("\n");
printf("1 zenbakia alde batera utzirik, prozesu errepikakorra 2 zenbakiarekin hasiko da\n\n");
while (iIterazioa * iIterazioa <= MAX)
{
printf("================================================================================\n");
if (!ardDatuak[iIterazioa].boMarkatua)
{
printf("%d zenbakia lehena da, %d zenbakiren multiploak markatzen...\n", iIterazioa, iIterazioa);
for (int k = iIterazioa + 1; k < MAX; k++)
{
if (ardDatuak[k].iKopurua % iIterazioa == 0)
{
ardDatuak[k].boMarkatua = true;
printf("%4d zenbakia markaturik zatigarria delako\n", ardDatuak[k].iKopurua);
}
}
}
else
{
printf("%d zenbakia zatigarria da\n", iIterazioa);
}
printf("%d arteko datuak:\n", iIterazioa);
ZenbakiakIkusi(ardDatuak, iLuzeraDatuak);
printf("================================================================================\n");
iIterazioa++;
if (iIterazioa * iIterazioa <= MAX)
{
printf(" %d x %d = %d <= %d prozesu errepikakorrarekin jarraitu\n", iIterazioa, iIterazioa, iIterazioa * iIterazioa, MAX);
}
else
{
printf(" %d x %d = %d > %d prozesu errepikakorra amaitu\n", iIterazioa, iIterazioa, iIterazioa * iIterazioa, MAX);
}
printf("\n\n");
}
LehenakLortu(ardDatuak, iLuzeraDatuak, aiLehenak, &iLuzeraLehenak);
printf("Lehenen zerrenda:\n");
LehenakIkusi(aiLehenak, iLuzeraLehenak);
printf("\n\nENTER sakatu exekuzioa amaitzeko... ");
getchar();
return 0;
}
// Datuak hasieratzen ditu
void DatuakLortu(tardZenbakiak ardDatuak, int *iLuzeraDatuak)
{
*iLuzeraDatuak = MAX;
for (int k = 2; k < *iLuzeraDatuak; k++) {
ardDatuak[k].iKopurua = k;
ardDatuak[k].boMarkatua = false;
}
}
// Zenbakiak ikusten ditu eta markatu gabeko lehenen kopurua kalkulatzen du
void ZenbakiakIkusi(const tardZenbakiak ardDatuak, int iLuzeraDatuak)
{
int iKont_TRUE = 0;
int iKont_FALSE = 1; // 1 zenbakia lehen gisa hartuta
printf("--------------------------------------------------------------------------------\n");
printf(" 1-FALSE");
for (int k = 2; k < iLuzeraDatuak; k++)
{
printf("%4d", ardDatuak[k].iKopurua);
if (ardDatuak[k].boMarkatua)
{
printf("--TRUE");
iKont_TRUE++;
}
else
{
printf("-FALSE");
iKont_FALSE++;
}
//printf("%d", ardDatuak[k].boMarkatua);
}
printf("\n--------------------------------------------------------------------------------\n");
printf(" Zenbakien kopurua = %d Lehenen kopurua = %d Zatigarrien kopurua = %d\n", iLuzeraDatuak, iKont_FALSE, iKont_TRUE);
}
// Lehen zenbakiak lortzen ditu
void LehenakLortu(const tardZenbakiak ardDatuak, int iLuzeraDatuak, taiLehenak aiLehenak, int *iLuzeraLehenak)
{
*iLuzeraLehenak = 1;
aiLehenak[*iLuzeraLehenak - 1] = 1;
for (int k = 2; k < iLuzeraDatuak; k++)
{
if (!ardDatuak[k].boMarkatua)
{
aiLehenak[(*iLuzeraLehenak)++] = ardDatuak[k].iKopurua;
}
}
}
// Lehen zenbakien zerrenda erakusten du
void LehenakIkusi(const taiLehenak aiLehenak, int iLuzeraLehenak)
{
printf("********************************************************************************\n");
for (int k = 1; k < iLuzeraLehenak; k++)
{
printf("%3d, ", aiLehenak[k]);
}
printf("\n********************************************************************************\n");
printf(" iLuzeraLehenak = %d\n", iLuzeraLehenak);
}
ZER IKASIKO DUDAN: Orain estruktura edo struct datu-motarekin jarraituko dut eta estrukturen arrayak erabili ahalko ditut.
Estrukturak: hasieraketak eta parametroak
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.
/* Ariketa-68_EstrukturenHasieraketa: estrukturak arrayak bezala hasieratzen dira */
// Parametroak izatean estrukturak float, int eta horrelako datu-mota
// xeheak bezala pasa daitezke funtzioetara: balioz eta erreferentziaz.
// Baina hobesten da estrukturari seinalatzen dion erakuslea pasatzea:
// estruktura sarrerako denean bere erakusleak const marka dara eta
// estruktura sarrera/irteerako denean bere erakusleak markarik ez du.
#include <stdio.h>
#include <string.h> // strcpy() funtziorako
#define LUZERAMAX 39+1
struct tstIkaslea
{
char sIzena[LUZERAMAX];
int iAdina;
float fNota;
};
void EstrukturaPantailaratu(const struct tstIkaslea *stIkasleBat);
void EstrukturaAldatu(struct tstIkaslea *stIkasleBat);
int main()
{
struct tstIkaslea stIkasleBat = {"Ana Ansa", 18, 7.95};
printf("\n");
printf("===========================================================\n");
printf(" Estrukturen hasieraketak eta estrukturak parametro bezala\n");
printf("===========================================================\n\n");
printf("'stIkasleBat' aldagaiaren hasieraketan balio hauek gorde dira:\n");
printf("\t stIkasleBat.sIzena = %s\n", stIkasleBat.sIzena);
printf("\t stIkasleBat.iAdina = %d\n", stIkasleBat.iAdina);
printf("\t stIkasleBat.fNota = %.2f\n", stIkasleBat.fNota);
printf("\nEstruktura bat 'balioz' igaro daiteke funtzio batera...");
printf("\nbaina, hobe bere erakusle babestua igarotzen badugu:\n");
EstrukturaPantailaratu(&stIkasleBat);
printf("\nEstruktura bat 'erreferentziaz' igaro daiteke funtzio batera...");
printf("\nbaina, hobe berari seinalzen dion erakuslea igarotzen badugu:\n");
EstrukturaAldatu(&stIkasleBat);
printf("EstrukturaAldatu() funtzio eta gero...\n");
printf("\t stIkasleBat.sIzena = %s\n", stIkasleBat.sIzena);
printf("\t stIkasleBat.iAdina = %d\n", stIkasleBat.iAdina);
printf("\t stIkasleBat.fNota = %.2f\n", stIkasleBat.fNota);
printf("\n");
printf("=====================================================\n");
printf(" RETURN sakatu amaitzeko \n");
printf("=====================================================\n");
getchar();
return 0;
}
void EstrukturaPantailaratu(const struct tstIkaslea *stIkasleBat)
{
printf("EstrukturaPantailaratu() funtzio barruan...\n");
printf("\t stIkasleBat.sIzena = %s\n", stIkasleBat->sIzena);
printf("\t stIkasleBat.iAdina = %d\n", stIkasleBat->iAdina);
printf("\t stIkasleBat.fNota = %.2f\n", stIkasleBat->fNota);
}
void EstrukturaAldatu(struct tstIkaslea *stIkasleBat)
{
printf("EstrukturaAldatu() funtzio barruan...\n");
strcpy(stIkasleBat->sIzena, "Mitxel Mitxelena");
stIkasleBat->iAdina = stIkasleBat->iAdina + 1;
stIkasleBat->fNota = stIkasleBat->fNota - 0.55;
}
Estrukturen array bat (eremu soilak)
Ikasgelako ikasle kopuru maximoa 10 izanik. Bildu array batean, ikasle bakoitzeko, irudian erakusten den informazio hau: izena, nota, helbidea, adina.
Ikusten denez, estrukturaren lau eremuak datu-mota soilak dira (ez dira datu-mota egituratuak, arrayak eta estrukturak bezala). Aplikatuko diren arrayen algoritmoak:
Array osoa prozesatu (media kalkulatzeko)
Array bat bi arrayetan banatu (mediatik beherakoak array batera, eta mediatik gorakoak beste array batera)
/* Ariketa-68a_EstrukturenArrayBat: Estrukturen arraya sortuko da, estrukturak
lau eremu ditu: kate bat, zenbaki erreal
bat, beste kate bat eta zenbaki oso bat. */
// Zenbat elementu izango diren teklatuz irakurri ondoren arraya datuz beteko da,
// ondoren arrayaren edukia erakutsiko da, estrukturen eremuak pantailaratuz.
// Aplikatuko diren arrayen algoritmoak:
// - Array osoa prozesatu (media kalkulatzeko)
// - Array bat bi arrayetan banatu (mediatik beherakoak array batera, eta
// mediatik gorakoak beste array batera)
#include <stdio.h>
struct tstIkasle
{
char sIzena[31];
float fNota;
char sHelbidea[91];
int iAdina;
};
void IkasleBatHartu(struct tstIkasle *stIkasle);
void ArrayaBete(struct tstIkasle astGela[], int *iLuzera);
void IkasleBatErakutsi(const struct tstIkasle *stIkasle);
void ArrayaIkusi(const struct tstIkasle astGela[], int iLuzera);
float fMediaKalkulatu(const struct tstIkasle astGela[], int iLuzera);
void Banatu(const struct tstIkasle astGela[], int iLuzera,
float fBBA,
struct tstIkasle astTxikiak[], int *iTxikienLuz,
struct tstIkasle astHandiak[], int *iHandienLuz);
int main()
{
struct tstIkasle astGela[10]; // gehienez 10 ikasle, indizeak 0-tik 9-ra
int iLuzera;
float fBBA;
struct tstIkasle astTxikiak[10];
int iTxikienLuz;
struct tstIkasle astHandiak[10];
int iHandienLuz;
printf("//////////////////////////////////////\n\n");
printf("Gelako datuak jaso.\n");
ArrayaBete(astGela, &iLuzera);
printf("\n");
printf("Gelako datuak ikusi.\n\n");
ArrayaIkusi(astGela, iLuzera);
printf("\n");
printf("Lehen ikaslearen adina %d da.\n", astGela[0].iAdina);
printf("Azken ikaslearen izena %s da.\n", astGela[iLuzera-1].sIzena);
printf("\n//////////////////////////////////////\n");
printf("\nArrayen algoritmoak");
printf("\n-------------------");
printf("\n - Array osoa prozesatu");
printf("\n - Array bat bitan banatu");
fBBA = fMediaKalkulatu(astGela, iLuzera);
printf("\n\nBatezbesteko aritmetikoa: %.3f\n\n", fBBA);
Banatu(astGela, iLuzera, fBBA, astTxikiak, &iTxikienLuz, astHandiak, &iHandienLuz);
printf("Mediatik beherako datuak ikusi.\n\n");
ArrayaIkusi(astTxikiak, iTxikienLuz);
printf("Mediatik gorako datuak ikusi.\n\n");
ArrayaIkusi(astHandiak, iHandienLuz);
printf("//////////////////////////////////////\n");
getchar();
return 0;
}
void IkasleBatHartu(struct tstIkasle *stIkasle)
{
printf("\tIkaslearen izena eman: ");
gets(stIkasle->sIzena);
printf("\tIkaslearen nota eman: ");
scanf("%f", &stIkasle->fNota);
getchar(); // Intro karakterea kendu
printf("\tIkaslearen helbidea eman: ");
gets(stIkasle->sHelbidea);
printf("\tIkaslearen adina eman: ");
scanf("%d", &stIkasle->iAdina);
getchar(); // Intro karakterea kendu
}
void ArrayaBete(struct tstIkasle astGela[], int *iLuzera)
{
int iKont;
do
{
printf("Zenbat ikasle dira? ");
scanf("%d", iLuzera);
getchar(); // Intro karakterea kendu
if (*iLuzera <= 0)
printf("Gutxienez ikasle bat. Errepikatu...\n");
if (*iLuzera > 10)
printf("Gehienez 10 ikasle. Errepikatu...\n");
} while (*iLuzera <= 0 || *iLuzera > 10);
printf("\n");
for (iKont = 0; iKont < *iLuzera; iKont++)
{
printf("%d indizedun ikaslearen datuak hartzen.\n", iKont);
IkasleBatHartu(&astGela[iKont]);
printf("\n");
}
}
void IkasleBatErakutsi(const struct tstIkasle *stIkasle)
{
printf("\tIkaslearen izena: %s\n", stIkasle->sIzena);
printf("\tIkaslearen nota: %.2f\n", stIkasle->fNota);
printf("\tIkaslearen helbidea: %s\n", stIkasle->sHelbidea);
printf("\tIkaslearen adina: %d\n", stIkasle->iAdina);
}
void ArrayaIkusi(const struct tstIkasle astGela[], int iLuzera)
{
int iKont;
for (iKont = 0; iKont < iLuzera; iKont++)
{
IkasleBatErakutsi(&astGela[iKont]);
printf("\n");
}
}
float fMediaKalkulatu(const struct tstIkasle astGela[], int iLuzera)
{
int iKont;
float fMetatua;
fMetatua = 0.0;
for (iKont = 0; iKont < iLuzera; iKont++)
{
fMetatua = fMetatua + astGela[iKont].fNota;
}
return fMetatua / iLuzera;
}
void Banatu(const struct tstIkasle astGela[], int iLuzera,
float fBBA,
struct tstIkasle astTxikiak[], int *iTxikienLuz,
struct tstIkasle astHandiak[], int *iHandienLuz)
{
int iKont;
int iKontTxiki;
int iKontHandi;
iKontTxiki = 0;
iKontHandi = 0;
for (iKont = 0; iKont < iLuzera; iKont++)
{
if (astGela[iKont].fNota < fBBA)
{
astTxikiak[iKontTxiki] = astGela[iKont];
iKontTxiki++;
}
else
{
astHandiak[iKontHandi] = astGela[iKont];
iKontHandi++;
}
}
*iTxikienLuz = iKontTxiki;
*iHandienLuz = iKontHandi;
}
Estrukturen array bat (eremu batean arraya)
Ikasgelako ikasle kopuru maximoa 10 izanik. Bildu array batean, ikasle bakoitzeko, irudian erakusten den informazio hau: izena, 1. abizena, 2. abizena eta nota.
Ikusten denez, estrukturaren bi eremuetatik bata array bat da (datu-mota egituratua) eta bestea zenbaki erreal bat (datu-mota soila). Zehatzak izanik, dauden bi karaktere-kateak datu-mota egituratuak dira arrayak direlako; baina, karaktere-kateak prozesatzeko erabiltzen den metodoa datu-mota soiletan egiten dena da.
Aplikatuko diren arrayen algoritmoak:
Bilaketa (while algoritmoz eta for algoritmoz)
Arrayaren elementu bat aldatu bere nota unitate batez inkrementatuz
/* Ariketa-68b_EstrukturenArrayBat: estrukturen arraya sortuko da, estrukturak
bi eremu ditu: hiru kateen array bat eta
zenbaki erreal bat. */
// Zenbat elementu izango diren teklatuz irakurri ondoren arraya datuz beteko da,
// ondoren arrayaren edukia erakutsiko da, estrukturen eremuak pantailaratuz.
// Aplikatuko diren arrayen algoritmoak:
// - Bilaketa (while eta for)
// - Arrayaren elementu bat aldatu bere nota unitate batez inkrementatuz
#include <stdio.h>
#include <string.h> // strcmp() funtziorako
#define MAX_KATEA 21
struct tstIkasle
{
char asIzenDeiturak[3][MAX_KATEA];
float fNota;
};
void IkasleBatHartu(struct tstIkasle *stIkasle);
void ArrayaBete(struct tstIkasle astGela[], int *iLuzera);
void IkasleBatErakutsi(const struct tstIkasle *stIkasle);
void ArrayaIkusi(const struct tstIkasle astGela[], int iLuzera);
int iBilatu_WHILE(const struct tstIkasle astGela[], int iLuzera, const char sGakoaIzena[]);
int iBilatu_FOR(const struct tstIkasle astGela[], int iLuzera, const char sGakoaIzena[]);
int main()
{
struct tstIkasle astGela[10]; // gehienez 10 ikasle, indizeak 0-tik 9-ra
int iLuzera;
char sGakoaIzena[MAX_KATEA];
int iNonDago;
printf("//////////////////////////////////////\n\n");
printf("Gelako datuak jaso.\n");
ArrayaBete(astGela, &iLuzera);
printf("\n");
printf("Gelako datuak ikusi.\n\n");
ArrayaIkusi(astGela, iLuzera);
printf("\n//////////////////////////////////////\n");
printf("\nArrayen algoritmoak");
printf("\n-------------------");
printf("\n - Bilaketa");
printf("\n - Arrayaren elementu bat aldatu\n");
printf("\nBilatu nahi den ikaslearen izena eman: ");
gets(sGakoaIzena);
iNonDago = iBilatu_WHILE(astGela, iLuzera, sGakoaIzena);
printf("\nBilaketa iBilatu_WHILE() funtzioz...");
if (iNonDago == -1)
printf("\n\t '%s' izeneko ikaslerik ez dago arrayan! \n", sGakoaIzena);
else
{
printf("\n\t '%s' izeneko ikaslearen lehen agerpena arrayan", sGakoaIzena);
printf("\n\t %d. posizioan ematen da. Bere notari +1 egin. \n", iNonDago);
astGela[iNonDago].fNota++;
IkasleBatErakutsi(&astGela[iNonDago]);
}
iNonDago = iBilatu_FOR(astGela, iLuzera, sGakoaIzena);
printf("\nBilaketa iBilatu_FOR() funtzioz...");
if (iNonDago == -1)
printf("\n\t '%s' izeneko ikaslerik ez dago arrayan! \n", sGakoaIzena);
else
{
printf("\n\t '%s' izeneko ikaslearen lehen agerpena arrayan", sGakoaIzena);
printf("\n\t %d. posizioan ematen da. Bere notari +1 egin. \n", iNonDago);
astGela[iNonDago].fNota++;
IkasleBatErakutsi(&astGela[iNonDago]);
}
printf("\n//////////////////////////////////////\n");
getchar();
return 0;
}
void IkasleBatHartu(struct tstIkasle *stIkasle)
{
printf("\t Ikaslearen izena eman: ");
gets(stIkasle->asIzenDeiturak[0]);
printf("\tIkaslearen 1. abizena eman: ");
gets(stIkasle->asIzenDeiturak[1]);
printf("\tIkaslearen 2. abizena eman: ");
gets(stIkasle->asIzenDeiturak[2]);
printf("\tIkaslearen nota eman: ");
scanf("%f", &stIkasle->fNota);
fflush(stdin); // Intro karakterea kendu
}
void ArrayaBete(struct tstIkasle astGela[], int *iLuzera)
{
int iKont;
do
{
printf("Zenbat ikasle dira? ");
scanf("%d", iLuzera);
getchar(); // Intro karakterea kendu
if (*iLuzera <= 0)
printf("Gutxienez ikasle bat. Errepikatu...\n");
if (*iLuzera > 10)
printf("Gehienez 10 ikasle. Errepikatu...\n");
} while (*iLuzera <= 0 || *iLuzera > 10);
printf("\n");
for (iKont = 0; iKont < *iLuzera; iKont++)
{
printf("%d indizedun ikaslearen datuak hartzen.\n", iKont);
IkasleBatHartu(&astGela[iKont]);
printf("\n");
}
}
void IkasleBatErakutsi(const struct tstIkasle *stIkasle)
{
printf("\t Ikaslearen izena: %s\n", stIkasle->asIzenDeiturak[0]);
printf("\tIkaslearen 1. abizena: %s\n", stIkasle->asIzenDeiturak[1]);
printf("\tIkaslearen 2. abizena: %s\n", stIkasle->asIzenDeiturak[2]);
printf("\t Ikaslearen nota: %.2f\n", stIkasle->fNota);
}
void ArrayaIkusi(const struct tstIkasle astGela[], int iLuzera)
{
int iKont;
for (iKont = 0; iKont < iLuzera; iKont++)
{
IkasleBatErakutsi(&astGela[iKont]);
printf("\n");
}
}
int iBilatu_WHILE(const struct tstIkasle astGela[], int iLuzera, const char sGakoaIzena[])
{
#define FALSE 0
#define TRUE 1
int iAurkitua; // bere balioak FALSE(0) eta TRUE(1)
int iKont;
iAurkitua = FALSE; // ez, oraindik ez da aurkitu
iKont = 0;
while (iAurkitua == FALSE && iKont <= iLuzera) // edo honela ere bai...
{ // (!iAurkitua && iKont <= iLuzera)
if (strcmp(astGela[iKont].asIzenDeiturak[0], sGakoaIzena) == 0)
iAurkitua = TRUE; // bai, aurkitu da
else
iKont++;
}
if (iAurkitua == TRUE) // edo honela ere bai...
// if (iAurkitua)
return iKont;
else
return -1;
}
int iBilatu_FOR(const struct tstIkasle astGela[], int iLuzera, const char sGakoaIzena[])
{
int iKont;
for (iKont = 0; iKont < iLuzera; iKont++)
{
if (strcmp(astGela[iKont].asIzenDeiturak[0], sGakoaIzena) == 0)
return iKont;
}
return -1;
}
Estrukturen array bat (estruktura habiaratuak)
Ikasgelako ikasle kopuru maximoa 10 izanik. Bildu array batean, ikasle bakoitzeko, irudian erakusten den informazio hau: izena, 1. abizena, 2. abizena eta nota.
Ikusten denez, estrukturaren hiru eremuetatik bata datu-mota egituratua da (estruktura bat delako), beste bat datu-mota soila da (zenbaki erreala) eta hirugarrena, karaktere-katea, erdibideko datu-mota da, izatez egituratua da arraya denaren aldetik, baina katea prozesatzean datu-mota soilak bezala jokatzen da.
Aplikatuko diren arrayen algoritmoak:
Maximoaren eta minimoaren posizioak zehaztu
Maximoaren eta minimoaren posizioak arrayan elkar trukatu
/* Ariketa-68c_EstrukturenArrayBat: Estrukturen arraya sortuko da, estrukturak
hiru eremu ditu: estruktura bat, kate bat
eta zenbaki erreal bat. */
// Zenbat elementu izango diren teklatuz irakurri ondoren arraya datuz beteko da,
// ondoren arrayaren edukia erakutsiko da, estrukturen eremuak pantailaratuz.
// Aplikatuko diren arrayen algoritmoak:
// - Maximoaren eta minimoaren posizioak zehaztu
// - Maximoaren eta minimoaren posizioak arrayan elkar trukatu
#include <stdio.h>
#define MAX_KATEA 21
struct tstData
{
int iUrtea;
int iHilea;
int iEguna;
};
struct tstIkasle
{
char sIzena[MAX_KATEA];
struct tstData stJaioeguna;
float fNota;
};
void IkasleBatHartu(struct tstIkasle *stIkasle);
void ArrayaBete(struct tstIkasle astGela[], int *iLuzera);
void IkasleBatErakutsi(const struct tstIkasle *stIkasle);
void ArrayaIkusi(const struct tstIkasle astGela[], int iLuzera);
int iMaximoaZehaztu(const struct tstIkasle astGela[], int iLuzera);
int iMinimoaZehaztu(const struct tstIkasle astGela[], int iLuzera);
int main()
{
struct tstIkasle astGela[10]; // gehienez 10 ikasle, indizeak 0-tik 9-ra
int iLuzera;
int iMaxNon;
int iMinNon;
struct tstIkasle stIkasleBat;
printf("//////////////////////////////////////\n\n");
printf("Gelako datuak jaso.\n");
ArrayaBete(astGela, &iLuzera);
printf("\n");
printf("Gelako datuak ikusi.\n\n");
ArrayaIkusi(astGela, iLuzera);
printf("\n//////////////////////////////////////\n");
printf("\nArrayen algoritmoak");
printf("\n-------------------");
printf("\n - Maximoa eta minimoa");
printf("\n - Arrayaren bi elementu posizioz trukatu\n");
iMaxNon = iMaximoaZehaztu(astGela, iLuzera);
iMinNon = iMinimoaZehaztu(astGela, iLuzera);
stIkasleBat = astGela[iMaxNon];
astGela[iMaxNon] = astGela[iMinNon];
astGela[iMinNon] = stIkasleBat;
printf("\nGelako datu berriak ikusi.\n\n");
ArrayaIkusi(astGela, iLuzera);
printf("//////////////////////////////////////\n");
getchar();
return 0;
}
void IkasleBatHartu(struct tstIkasle *stIkasle)
{
printf("\t Ikaslearen izena eman: ");
gets(stIkasle->sIzena);
printf("\tIkaslearen jaiotze urtea: ");
scanf("%d", &stIkasle->stJaioeguna.iUrtea);
printf("\tIkaslearen jaiotze hilea: ");
scanf("%d", &stIkasle->stJaioeguna.iHilea);
printf("\tIkaslearen jaiotze eguna: ");
scanf("%d", &stIkasle->stJaioeguna.iEguna);
printf("\t Ikaslearen nota eman: ");
scanf("%f", &stIkasle->fNota);
getchar(); // Intro karakterea kendu
}
void ArrayaBete(struct tstIkasle astGela[], int *iLuzera)
{
int iKont;
do
{
printf("Zenbat ikasle dira? ");
scanf("%d", iLuzera);
getchar(); // Intro karakterea kendu
if (*iLuzera <= 0)
printf("Gutxienez ikasle bat. Errepikatu...\n");
if (*iLuzera > 10)
printf("Gehienez 10 ikasle. Errepikatu...\n");
} while (*iLuzera <= 0 || *iLuzera > 10);
printf("\n");
for (iKont = 0; iKont < *iLuzera; iKont++)
{
printf("%d indizedun ikaslearen datuak hartzen.\n", iKont);
IkasleBatHartu(&astGela[iKont]);
printf("\n");
}
}
void IkasleBatErakutsi(const struct tstIkasle *stIkasle)
{
printf("\t Ikaslearen izena: %s\n", stIkasle->sIzena);
printf("\tJaoitze data, urtea: %d\n", stIkasle->stJaioeguna.iUrtea);
printf("\t hilea: %d\n", stIkasle->stJaioeguna.iHilea);
printf("\t eguna: %d\n", stIkasle->stJaioeguna.iEguna);
printf("\t Ikaslearen nota: %.2f\n", stIkasle->fNota);
}
void ArrayaIkusi(const struct tstIkasle astGela[], int iLuzera)
{
int iKont;
for (iKont = 0; iKont < iLuzera; iKont++)
{
IkasleBatErakutsi(&astGela[iKont]);
printf("\n");
}
}
int iMaximoaZehaztu(const struct tstIkasle astGela[], int iLuzera)
{
int iMaximoarenPosizioa;
float fMaximoa;
int iKont;
iMaximoarenPosizioa = 0;
fMaximoa = astGela[0].fNota;
for (iKont = 1; iKont < iLuzera; iKont++)
{
if (astGela[iKont].fNota > fMaximoa)
{
iMaximoarenPosizioa = iKont;
fMaximoa = astGela[iKont].fNota;
}
}
return iMaximoarenPosizioa;
}
int iMinimoaZehaztu(const struct tstIkasle astGela[], int iLuzera)
{
int iMinimoarenPosizioa;
float fMinimoa;
int iKont;
iMinimoarenPosizioa = 0;
fMinimoa = astGela[0].fNota;
for (iKont = 1; iKont < iLuzera; iKont++)
{
if (astGela[iKont].fNota < fMinimoa)
{
iMinimoarenPosizioa = iKont;
fMinimoa = astGela[iKont].fNota;
}
}
return iMinimoarenPosizioa;
}
Estruktura konplexu baten arraya
Ikasgelako ikasle kopuru maximoa 25 izanik. Bildu array batean, ikasle bakoitzeko, irudian erakusten den informazio hau, non zenbakizko balioak auzaz lortuko diren.
Ikusten denez, estrukturaren sei eremuetatik bi datu-mota egituratuak dira (estruktura bat eta array bat), beste bi datu-mota soilak dira (zenbaki osoa eta zenbaki erreala) eta gainerako beste biak, karaktere-kateak direlako, erdibideko datu-mota dagokie, izatez egituratua da arraya denaren aldetik, baina katea prozesatzean datu-mota soilak bezala jokatzen da.
/* Ariketa-68d_EstrukturenArrayBat: Estrukturen arraya sortuko da, estrukturak
sei eremu ditu: kateak, zenbaki errealak,
zenbaki osoa eta beste estruktura bat. */
// Zenbat elementu izango diren teklatuz irakurri ondoren arraya datuz beteko da,
// zenbakizkoak diren datuak (deialdia, notak eta data) auzaz beteko dira.
// Ondoren, arrayaren edukia erakutsiko da, estrukturen eremuak pantailaratuz.
#include <stdio.h>
#include <stdlib.h> // rand() eta srand() funtzioetarako
#include <time.h> // time() funtzioarako
#define IKASLE_KOP_MAX 25
struct tstData
{
int iUrtea;
int iHilea;
int iEguna;
};
struct tstIkasle
{
char sIzena[31];
char sHelbidea[91];
struct tstData stJaioeguna;
int iDeialdia;
float afKontrolak[3];
float fAzkenNota;
};
void IkasleBatHartu(struct tstIkasle *stIkasle);
void ArrayaBete(struct tstIkasle astIkasgela[], int *iLuzera);
void IkasleBatErakutsi(const struct tstIkasle *stIkasle);
void ArrayaIkusi(const struct tstIkasle astIkasgela[], int iLuzera);
int main()
{
struct tstIkasle astIkasgela[IKASLE_KOP_MAX]; // gehienez 25 ikasle, indizeak 0-tik 24-ra
int iLuzera;
printf("//////////////////////////////////////\n\n");
printf("Gelako datuak jaso.\n");
ArrayaBete(astIkasgela, &iLuzera);
printf("\nGelako datuak ikusi.\n\n");
ArrayaIkusi(astIkasgela, iLuzera);
printf("//////////////////////////////////////\n");
getchar();
return 0;
}
void IkasleBatHartu(struct tstIkasle *stIkasle)
{
printf("\tIkaslearen izena eman: ");
gets(stIkasle->sIzena);
printf("\tIkaslearen helbidea eman: ");
gets(stIkasle->sHelbidea);
srand(time(NULL)); // srand() zenbaki aleatorioak berriro hasiarazteko, srand()-ek hazia behar duenez,
// time(NULL) funtzioak igarotako segundoak itzultzen ditu 1970-01-01 datatik hasita
stIkasle->stJaioeguna.iUrtea = rand() % 5 + 2000; // [(0 eta 4 artekoa) + 2000] = [2000 eta 2004 artekoa]
stIkasle->stJaioeguna.iHilea = rand() % 12 + 1; // [(0 eta 11 artekoa) + 1] = [1 eta 12 artekoa]
stIkasle->stJaioeguna.iEguna = rand() % 28 + 1; // [(0 eta 27 artekoa) + 1] = [1 eta 28 artekoa]
printf("\tJaiotze-data: %d/%02d/%02d", stIkasle->stJaioeguna.iUrtea, stIkasle->stJaioeguna.iHilea, stIkasle->stJaioeguna.iEguna);
stIkasle->iDeialdia = rand() % 6 + 1; // [(0 eta 5 artekoa) + 1] = [1 eta 6 artekoa]
printf("\n\tIkaslearen deialdia: %d", stIkasle->iDeialdia);
if (stIkasle->iDeialdia == 6)
printf(" (graziako deialdia)");
for (int iKont = 0; iKont < 3; iKont++)
{
stIkasle->afKontrolak[iKont] = rand() % 10 + 0.1*(rand() % 10);
printf("\n\t%d. kontroleko nota: %.1f", iKont+1, stIkasle->afKontrolak[iKont]);
}
stIkasle->fAzkenNota = (stIkasle->afKontrolak[0] +
stIkasle->afKontrolak[1] +
stIkasle->afKontrolak[2]) / 3;
printf("\n\tAzken nota: %.2f\n", stIkasle->fAzkenNota);
}
void ArrayaBete(struct tstIkasle astIkasgela[], int *iLuzera)
{
int iKont;
do
{
printf("Zenbat ikasle dira? ");
scanf("%d", iLuzera);
getchar(); // Intro karakterea kendu
if (*iLuzera <= 0)
printf("Gutxienez ikasle bat. Errepikatu...\n");
if (*iLuzera > IKASLE_KOP_MAX)
printf("Gehienez 10 ikasle. Errepikatu...\n");
} while (*iLuzera <= 0 || *iLuzera > IKASLE_KOP_MAX);
printf("\n");
for (iKont = 0; iKont < *iLuzera; iKont++)
{
printf("%d indizedun ikaslearen datuak hartzen...\n", iKont);
IkasleBatHartu(&astIkasgela[iKont]);
printf("\n");
}
}
void IkasleBatErakutsi(const struct tstIkasle *stIkasle)
{
printf("\tIkaslearen izena: %s\n", stIkasle->sIzena);
printf("\tIkaslearen helbidea: %s\n", stIkasle->sHelbidea);
if (stIkasle->iDeialdia == 6)
printf("\tAdi!!! Graziako deialdia: %d\n", stIkasle->iDeialdia);
else
printf("\tIkaslearen deialdia: %d\n", stIkasle->iDeialdia);
printf("\tIkaslearen jaiotze-data: %d/%02d/%02d\n", stIkasle->stJaioeguna.iUrtea, stIkasle->stJaioeguna.iHilea, stIkasle->stJaioeguna.iEguna);
for (int iKont = 0; iKont < 3; iKont++)
{
printf("\t%d. kontrolekoa: %.1f\n", iKont+1, stIkasle->afKontrolak[iKont]);
}
printf("\tIkaslearen azken nota: %.2f\n", stIkasle->fAzkenNota);
}
void ArrayaIkusi(const struct tstIkasle astIkasgela[], int iLuzera)
{
int iKont;
for (iKont = 0; iKont < iLuzera; iKont++)
{
printf("%d indizedun ikaslearen datuak hemen...\n", iKont);
IkasleBatErakutsi(&astIkasgela[iKont]);
printf("\n");
}
}
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:
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.
