| ZER DAKIDAN: Ariketa 64 | Bi array paralelo adibidea eta Ariketa 65 | Kateen taula programatu ditudanean array paralelo edo array dimentsioanitza antolatu behar izan ditut. 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:
|
/* 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:
|
/* 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:
|
/* 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");
}
}
|
iruzkinik ez:
Argitaratu iruzkina