ZER DAKIDAN: Fitxategiak zer diren badakit, eta fitxategi batek bere tokia hartzen duela diskoan badakit.
ZER IKASIKO DUDAN: Fitxategi bat diskotik ezabatzen duen programa idatziko dut.
Datuak gordetzen dituen fitxategi bat daukagu. Esate baterako, erregistroen fitxategi bat daukagu eta programaren helburua da diskotik fitxategia ezabatzea.
Izena ezabatzeko funtzioa remove() da eta bere dei honetan ikus daitekeen bezala, behar duen parametro bakarra katea da:
remove(sFitxIzen)
Horregatik, fitxategi bat ezabatuko duen funtzio batek ez du FILE datu-motako aldagairik beharko.
Erakusten den programa honetan jatorrizko fitxategiaren existentzia frogatzen da programa nagusian fileexists() funtzioa erabiliz, ondoren fitxategia ezabatu aurretik fitxategiaren edukia pantailaratzen da.
/* Ariketa-87_Fitxategien_12_algoritmoa: ezabatu */
// boFitxategiaExistitzenDa() funtzioa erabili da konprobazioak egiteko,
// baina fitxategia ezabatzeko funtsezko funtzioa remove(sFitxIzen) da
// eta remove() funtzioak katea behar duenez ez da fitxategirik irekiko.
#include <stdio.h>
#include <stdbool.h> // bool datu-motarako
typedef char tsKate99[100]; // fitxategiaren izenerako 99 karaktere gehi null mugatzailea
typedef char tsKate49[50]; // ikaslearen izena gordetzeko 49 karaktere gehi null mugatzailea
typedef struct
{
tsKate49 sIzenDeiturak;
unsigned int byDeialdia;
float fNota;
} trdFitxa;
bool boFitxategiaExistitzenDa(const tsKate99 sFitxIzen);
void FitxategiaIkusi(const tsKate99 sFitxIzen);
void FitxategiaEzabatu(const tsKate99 sFitxIzen);
int main()
{
tsKate99 sFitxIzen = "C:\\Tokia\\Fitxak_.dat";
printf("'%s' fitxategiarekin lan egingo dugu.\n", sFitxIzen);
if (boFitxategiaExistitzenDa(sFitxIzen))
{
FitxategiaIkusi(sFitxIzen);
FitxategiaEzabatu(sFitxIzen);
printf("'%s' fitxategia existitzen da? ERANTZUNA ---> %s\n", sFitxIzen, boFitxategiaExistitzenDa(sFitxIzen) ? "BAI" : "EZ");
}
else
printf("'%s' fitxategia ez da existitzen.\n", sFitxIzen);
printf("\nRETURN sakatu programa bukatzeko\n");
getchar();
return 0;
}
// fitxategiaren edukia bistaratzeko
void FitxategiaIkusi(const tsKate99 sFitxIzen)
{
FILE *fFitxategia;
trdFitxa rdElem;
long int liPosizioa;
fFitxategia = fopen(sFitxIzen, "rb");
if (!fFitxategia)
{
printf("Ezin da fitxategia ireki\n");
return;
}
printf("'%s' fitxategiaren edukia:\n", sFitxIzen);
liPosizioa = 0;
while (fread(&rdElem, sizeof(trdFitxa), 1, fFitxategia) == 1)
{
printf("%2ld posizioan %-15s %8d %10.2f\n", liPosizioa, rdElem.sIzenDeiturak, rdElem.byDeialdia, rdElem.fNota);
liPosizioa++;
}
printf("\n");
fclose(fFitxategia);
}
void FitxategiaEzabatu(const tsKate99 sFitxIzen)
{
if (remove(sFitxIzen) == 0)
printf("'%s' fitxategia ezabatu da.\n", sFitxIzen);
else
printf("Errorea '%s' ezabatzerakoan.\n", sFitxIzen);
}
bool boFitxategiaExistitzenDa(const tsKate99 sFitxIzen)
{
FILE *file = fopen(sFitxIzen, "rb");
if (file) {
fclose(file);
return true;
}
return false;
}
ZER DAKIDAN: Fitxategiak zer diren badakit, eta fitxategi batek bere izena duela badakit.
ZER IKASIKO DUDAN: Fitxategi bati bere izena aldatzen dion programa idatziko dut.
Datuak gordetzen dituen fitxategi bat daukagu. Esate baterako, erregistroen fitxategi bat daukagu eta diskoan duen bere izena aldatu nahi zaio bere elementuak berdin-berdin mantenduz.
Izena aldatzeko funtzioa rename() da eta bere dei honetan ikus daitekeen bezala, behar dituen bi parametroak kateak dira:
rename(sFitxIzenZaharra, sFitxIzenBerria)
Horregatik, fitxategi bati izena aldatuko dion funtzio batek ez du FILE datu-motako aldagairik beharko.
Erakusten den programa honetan jatorrizko fitxategiaren existentzia frogatzen da programa nagusian fileexists() funtzioa erabiliz, ondoren fileexists() funtzioa berriro erabili izen berriko fitxategirik ez dagoela konprobatzen da.
Baldintza biak betetzen badira, hots, jatorrizko fitxategia existentzen dela eta izen berriko fitxategirik ez dagoela, rename() funtzioan oinarrituta izen berria ezartzen zaio jatorrizko fitxategiari.
/* Ariketa-86_Fitxategien_11_algoritmoa: berrizendatu */
// boFitxategiaExistitzenDa() funtzioa erabili da konprobazioak egiteko,
// baina funtsezko funtzioa rename(sFitxIzen,sFitxIzenBerria) da izena
// aldatzeko balio duelako, rename() funtzioak kateekin lan egiten duenez
// ez dago zertan fitxategirik ireki behar.
#include <stdio.h>
#include <stdbool.h> // bool datu-motarako
typedef char tsKate99[100]; // fitxategiaren izenerako 99 karaktere gehi null mugatzailea
typedef char tsKate49[50]; // ikaslearen izena gordetzeko 49 karaktere gehi null mugatzailea
typedef struct
{
tsKate49 sIzenDeiturak;
unsigned int byDeialdia;
float fNota;
} trdFitxa;
bool boFitxategiaExistitzenDa(const tsKate99 sFitxIzen);
void FitxategiaIkusi(const tsKate99 sFitxIzen);
void FitxategiaBerrizendatu(const tsKate99 sFitxIzen, const tsKate99 sFitxIzenBerria);
int main()
{
tsKate99 sFitxIzenZaharra = "C:\\Tokia\\Datuak.dat";
tsKate99 sFitxIzenBerria = "C:\\Tokia\\Fitxak.dat";
printf("'%s' fitxategiarekin lan egingo dugu.\n", sFitxIzenZaharra);
printf("'%s' fitxategia existitzen da? ERANTZUNA ---> %s\n", sFitxIzenZaharra, boFitxategiaExistitzenDa(sFitxIzenZaharra) ? "BAI" : "EZ");
printf("'%s' fitxategia existitzen da? ERANTZUNA ---> %s\n", sFitxIzenBerria, boFitxategiaExistitzenDa(sFitxIzenBerria) ? "BAI" : "EZ");
printf("\n");
if (boFitxategiaExistitzenDa(sFitxIzenZaharra))
{
printf("'%s' fitxategiaren edukia:\n", sFitxIzenZaharra);
FitxategiaIkusi(sFitxIzenZaharra);
printf("\n");
if (!boFitxategiaExistitzenDa(sFitxIzenBerria))
{
FitxategiaBerrizendatu(sFitxIzenZaharra, sFitxIzenBerria);
printf("'%s' fitxategiaren edukia:\n", sFitxIzenBerria);
FitxategiaIkusi(sFitxIzenBerria);
}
else
{
printf("Ezin daiteke berrizendatu, '%s' izena hartuta dagoelako.\n", sFitxIzenBerria);
}
printf("\n");
printf("'%s' fitxategia existitzen da? ERANTZUNA ---> %s\n", sFitxIzenZaharra, boFitxategiaExistitzenDa(sFitxIzenZaharra) ? "BAI" : "EZ");
printf("'%s' fitxategia existitzen da? ERANTZUNA ---> %s\n", sFitxIzenBerria, boFitxategiaExistitzenDa(sFitxIzenBerria) ? "BAI" : "EZ");
}
else
{
printf("'%s' fitxategia ez da existitzen.\n", sFitxIzenZaharra);
}
printf("\nRETURN sakatu programa bukatzeko\n");
getchar();
return 0;
}
// fitxategiaren edukia bistaratzeko
void FitxategiaIkusi(const tsKate99 sFitxIzen)
{
FILE *fFitxategia;
trdFitxa rdElem;
long int liPosizioa;
fFitxategia = fopen(sFitxIzen, "rb");
if (!fFitxategia)
{
printf("Ezin da fitxategia ireki\n");
return;
}
printf("'%s' fitxategiaren edukia:\n", sFitxIzen);
liPosizioa = 0;
while (fread(&rdElem, sizeof(trdFitxa), 1, fFitxategia) == 1)
{
printf("%2ld posizioan %-15s %8d %10.2f\n", liPosizioa, rdElem.sIzenDeiturak, rdElem.byDeialdia, rdElem.fNota);
liPosizioa++;
}
printf("\n");
fclose(fFitxategia);
}
void FitxategiaBerrizendatu(const tsKate99 sFitxIzenZaharra, const tsKate99 sFitxIzenBerria)
{
if (rename(sFitxIzenZaharra, sFitxIzenBerria) == 0)
printf("Fitxategiaren izena '%s' izenera aldatu da.\n", sFitxIzenBerria);
else
printf("Errorea izena aldatzean.\n");
}
bool boFitxategiaExistitzenDa(const tsKate99 sFitxIzen)
{
FILE *file;
file = fopen(sFitxIzen, "rb");
if (file)
{
fclose(file);
return true;
}
return false;
}
ZER IKASIKO DUDAN: Informazioa fitxategi batean daukadala Maximo/Minimo algoritmoa ikasiko dut.
Datuak gordetzen dituen fitxategi bat daukagu. Esate baterako, estrukturen fitxategi bat daukagu eta ezagutu nahi da notarik handiena zein ikasleari dagokion; gauza bera egin nahi da notarik txikienarekin. Hau da, fNota eremuko maximoa eta minimoa zehaztu nahi dira.
Maximoa dela eta, argi eduki beharra dago zer helburu jarrita daukagun, eta, horren arabera, funtzioak hiru datu-mota desberdin itzul ditzake:
Maximoaren edo minimoaren indizea fitxategian ezagutu nahi da, kasu honetan funtzioaren prototipoa hau izango da: long liNotaMaximoarenIndizeaZehaztu(const char sFitxIzen[]);
Maximoaren edo minimoaren balioa ezagutu nahi da, kasu honetan funtzioaren prototipoa hau izango da: float fNotaMaximoarenIndizeaZehaztu(const char sFitxIzen[]);
Maximoaren edo minimoaren indizea estruktura osoa ezagutu nahi da, orduan prototipoa hau izango da: struct tstFitxa stNotaMaximoarenIndizeaZehaztu(const char sFitxIzen[]);
Algoritmia aldetik, berdina da maximoa zehaztea edo minimoa zehaztea. Oso antzekoak izan arren, jarraian ematen diren bi adibideetan erabilitako algoritmoak desberdinak dira, bietariko batean hasieraketak derrigorrezkoak direlako:
Ariketa-85_Fitxategien_10a_algoritmoa adibidean maximoaren ikaslea zehazten da (fNota handiena duen ikaslea) eta fitxategiko lehen irakurketa while agindutik kanpo egiten da
Ariketa-85_Fitxategien_10b_algoritmoa adibidean minimoaren ikaslea zehazten da (fNota txikiena duen ikaslea) eta fitxategiko irakurketa guztiak while aginduaren barruan egiten direlako, aldagaien hasieraketek berebiziko garrantzia dute
Erakusten den programa honetan fitxategiaren existentzia frogatzen da programa nagusian, horren arabera:
Baldin eta fitxategia bada maximoa eta minimoa zehaztuko dira
Fitxategirik ez bada, programa amaitu aurretik mezu batez adierazten da
Fitxategirik bada, lehenik eta zenbat elementu dituen kalkulatuko da eta emaitza liZenbatElem izeneko aldagaian gordeko da. Elementu bat baino gehiago badira programak honelaxe jokatuko du:
liNotaMaximoarenPosizioaZehaztu() funtzioaren bitartez notarik handienari dagokion elementuaren posizioa lortuko da, liNotaMaxNon posizioa
liNotaMaxNon balioari esker dagokion elementuaren datuak pantailaratuko dira IkasleBatenDatuakErakutsi funtzioari deituz
liNotaMinimoarenPosizioaZehaztu() funtzioaren bitartez notarik txikienari dagokion elementuaren posizioa lortuko da, liNotaMinNon posizioa
liNotaMinNon balioari esker dagokion elementuaren datuak pantailaratuko dira aurreko IkasleBatenDatuakErakutsi funtzioari deituz
/* Ariketa-85_Fitxategien_10a_algoritmoa: maximoa */
// Erregistroen fitxategi bat datuz beterik daukagu eta notarik handiena
// zein ikasleari dagokion jakin nahi da, gauza bera notarik txikienarekin.
// Algoritmia aldetik lan honetan fitxategi osoa arakatu behar da, baina
// fitxategiaren lehen elementua prozesu errepikakorretik kanpo irakurtzen
// da eta hori da hasierako minimoa edo maximoa.
#include <stdio.h>
#include <string.h> // strcpy() eta strcat() funtzioetarako
#include <conio.h> // getch() funtziorako
#define FITX_IZEN_MAX 120 // fitxategiaren izenerako 119 karaktere gehi null mugatzailea
#define DATU_IZEN_MAX 72 // ikaslearen izena gordetzeko 71 karaktere gehi null mugatzailea
struct tstFitxa // struct definitzen ikasleen datuak gordetzeko
{
char sIzenDeiturak[DATU_IZEN_MAX];
int iDeialdia;
float fNota;
};
int iFitxategirikBada(const char sFitxIzen[]);
long int liFitxategiarenElemKopKalkulatu(const char sFitxIzen[]);
long liNotaMaximoarenIndizeaZehaztu(const char sFitxIzen[]);
long liNotaMinimoarenIndizeaZehaztu(const char sFitxIzen[]);
void IkasleBatenDatuakErakutsi(const char sFitxIzen[], long liNotaMaxNon);
int main()
{
char sFitxIzen[FITX_IZEN_MAX];
char sFitxIzenLaburra[FITX_IZEN_MAX];
long liZenbatElem;
long liNotaMaxNon;
long liNotaMinNon;
printf("Fitxategia existitzen da eta datuak ditu (adibidez C:\\Tokia\\Ikasleak.DAT)\n");
printf("''C:\\Tokia\\'' karpetako fitxategiaren izen laburra eman ezazu.\n");
printf("Adibidez, 'Datuak' izena: ");
scanf("%s", sFitxIzenLaburra);
getchar(); // Enter karakterea kentzeko
strcpy(sFitxIzen, "C:\\Tokia\\");
strcat(sFitxIzen, sFitxIzenLaburra);
strcat(sFitxIzen, ".dat");
printf("\n");
if (iFitxategirikBada(sFitxIzen) == 1)
{
printf("Notarik handiena zein ikasleri dagokio %s fitxategian?\n", sFitxIzen);
printf("Notarik txikiena zein ikasleri dagokio %s fitxategian?\n", sFitxIzen);
liZenbatElem = liFitxategiarenElemKopKalkulatu(sFitxIzen);
switch (liZenbatElem)
{
case 0: printf("'%s' fitxategia existitzen da baina hutsik dago.\n", sFitxIzen);
break;
case 1: printf("'%s' fitxategia existitzen da eta elementu bakarra du\n", sFitxIzen);
printf("\nIkaslerik onena eta txarrena...");
IkasleBatenDatuakErakutsi(sFitxIzen, 0);
break;
default: liNotaMaxNon = liNotaMaximoarenIndizeaZehaztu(sFitxIzen);
printf("\nIkaslerik onena...");
IkasleBatenDatuakErakutsi(sFitxIzen, liNotaMaxNon); // ikaslerik onena
liNotaMinNon = liNotaMinimoarenIndizeaZehaztu(sFitxIzen);
printf("\nIkaslerik txarrena...");
IkasleBatenDatuakErakutsi(sFitxIzen, liNotaMinNon); // ikaslerik txarrena
}
}
else
printf("'%s' fitxategia ez da existitzen, agur...", sFitxIzen);
printf("\nPrograma bukatzera doa. Edozein tekla sakatu! ");
getch(); // itxaron edozein tekla sakatu arte
printf("\n");
return 0;
}
// funtzio honek fitxategi baten existentzia frogatzen du.
int iFitxategirikBada(const char sFitxIzen[])
{
FILE *f;
// Irakurketarako irekitze saiakera ("r" = read)
f = fopen(sFitxIzen, "rb");
// Fitxategirik ez balego fopen() funtzioak NULL itzuliko luke
if (f != NULL)
{
fclose(f); // fitxategia itxi baliabidwak askatzeko
return 1; // Itzuli 1 (true): fitxategia bada
}
// Fitxategirik ez balego fopen() funtzioak NULL itzuliko luke
return 0; // Itzuli 0 (false): fitxategia ez da existitzen
}
// fitxategiko elementu kopurua itzultzeko
long int liFitxategiarenElemKopKalkulatu(const char sFitxIzen[])
{
FILE *fFitxategia;
long int liElemKopurua = 0;
fFitxategia = fopen(sFitxIzen, "rb");
if (!fFitxategia)
{
printf("Ezin da fitxategia ireki\n");
return -1;
}
fseek(fFitxategia, 0L, SEEK_END);
liElemKopurua = ftell(fFitxategia) / sizeof(struct tstFitxa);
fclose(fFitxategia);
return liElemKopurua;
}
// lehen irakurketa while kanpoan egin daiteke ezaguna delako
// fitxategiak 2 elementu edo gehiago dituela. Maximoa non
// dagoen zehazteko fitxategiaren uneko indizea kalkulatzen da.
long liNotaMaximoarenIndizeaZehaztu(const char sFitxIzen[])
{
FILE *f;
struct tstFitxa stElem;
float fMaximoa;
long liMaximoaNon;
f = fopen(sFitxIzen, "rb");
fread(&stElem, sizeof(struct tstFitxa), 1, f); // hasieran lehen elementuan dago maximoa
fMaximoa = stElem.fNota;
liMaximoaNon = 0;
while (fread(&stElem, sizeof(struct tstFitxa), 1, f))
{
if (stElem.fNota > fMaximoa)
{
fMaximoa = stElem.fNota;
liMaximoaNon = ftell(f) / sizeof(struct tstFitxa) - 1; // uneko indizearen aurrekoa
}
}
fclose(f);
return liMaximoaNon;
}
// lehen irakurketa while kanpoan egin daiteke ezaguna delako
// fitxategiak 2 elementu edo gehiago dituela. Minimoa non
// dagoen zehazteko fitxategiaren uneko indizea kalkulatzen da.
long liNotaMinimoarenIndizeaZehaztu(const char sFitxIzen[])
{
FILE *f;
struct tstFitxa stElem;
float fMinimoa;
long liMinimoaNon;
f = fopen(sFitxIzen, "rb");
fread(&stElem, sizeof(struct tstFitxa), 1, f); // hasieran lehen elementuan dago minimoa
fMinimoa = stElem.fNota;
liMinimoaNon = 0;
while (fread(&stElem, sizeof(struct tstFitxa), 1, f))
{
if (stElem.fNota < fMinimoa)
{
fMinimoa = stElem.fNota;
liMinimoaNon = ftell(f) / sizeof(struct tstFitxa) - 1; // uneko indizearen aurrekoa
}
}
fclose(f);
return liMinimoaNon;
}
void IkasleBatenDatuakErakutsi(const char sFitxIzen[], long liNotaNon)
{
FILE *f;
struct tstFitxa stElem;
f = fopen(sFitxIzen, "rb");
fseek(f, liNotaNon*(long)sizeof(struct tstFitxa), SEEK_SET);
fread(&stElem, sizeof(struct tstFitxa), 1, f);
printf("\n%ld indizeko ikaslearen datuak hauek dira:\n", liNotaNon);
printf("Nor ---------> %s\n", stElem.sIzenDeiturak);
printf("Deialdia ----> %d\n", stElem.iDeialdia);
printf("Nota --------> %.2f\n", stElem.fNota);
fclose(f);
}
Erakusten den programa honetan fitxategiaren existentzia frogatzen da programa nagusian, horren arabera:
Baldin eta fitxategia bada maximoa eta minimoa zehaztuko dira
Fitxategirik ez bada, programa amaitu aurretik mezu batez adierazten da
Fitxategirik bada, lehenik eta zenbat elementu dituen kalkulatuko da eta emaitza liZenbatElem izeneko aldagaian gordeko da. Elementu bat baino gehiago badira programak lehen bezala jokatuko du, non liNotaMaximoarenPosizioaZehaztu() funtzioa eta liNotaMinimoarenPosizioaZehaztu() funtzioa honela programatu diren:
// hiru hasierakerak guztiz derrigorrezkoak dira:
// - konparaketak abiatzeko nota faltsu bat
// - nota faltsuari dagokion posizio faltsua
// - maximoaren posizioa finkatuko duen kontagailua
long liNotaMaximoarenPosizioaZehaztu(const char sFitxIzen[])
{
FILE *f;
tstFitxa rdElem;
float fMaximoa = -1.0; // nota faltsua
long liMaximoaNon = -1; // indize faltsua
long liIndizea = 0; // kontagailuaren hasieraketa
f = fopen(sFitxIzen, "rb");
while (fread(&stElem, sizeof(struct tstFitxa), 1, f))
...
// hiru hasierakerak guztiz derrigorrezkoak dira:
// - konparaketak abiatzeko nota faltsu bat
// - nota faltsuari dagokion posizio faltsua
// - minimoaren posizioa finkatuko duen kontagailua
long liNotaMaximoarenPosizioaZehaztu(const char sFitxIzen[])
{
FILE *f;
trdFitxa stElem;
float fMinimoa = 11.0; // nota faltsua
long liMinimoaNon = -1; // indize faltsua
long liIndizea = 0; // kontagailuaren hasieraketa
f = fopen(sFitxIzen, "rb");
while (fread(&stElem, sizeof(struct tstFitxa), 1, f))
...
Argi ikusten da hasieraketak zertxobait artifizialak direla: fMaximoa aldagairako ahalik eta baliorik txikiena aukeratzen zaio (gure ariketan ezinezkoa den -1.0 nota ezarri zaio), eta fMinimoa aldagairako ahalik eta baliorik handiena aukeratzen zaio (gure ariketan ezinezkoa den 11.0 nota esleitu zaio). Horregatik, gehienetan Ariketa-85_Fitxategien_10a_algoritmoa ariketan emandako algoritmoa programatuko dugu.
/* Ariketa-85_Fitxategien_10b_algoritmoa: maximoa */
// Erregistroen fitxategi bat datuz beterik daukagu eta notarik handiena
// zein ikasleari dagokion jakin nahi da, gauza bera notarik txikienarekin.
// Algoritmia aldetik lan honetan fitxategi osoa arakatu behar da, baina
// kontu handia eduki behar da hiru aldagaien hasieraketekin.
#include <stdio.h>
#include <string.h> // strcpy() eta strcat() funtzioetarako
#include <conio.h> // getch() funtziorako
#define FITX_IZEN_MAX 120 // fitxategiaren izenerako 119 karaktere gehi null mugatzailea
#define DATU_IZEN_MAX 72 // ikaslearen izena gordetzeko 71 karaktere gehi null mugatzailea
struct tstFitxa // struct definitzen ikasleen datuak gordetzeko
{
char sIzenDeiturak[DATU_IZEN_MAX];
int iDeialdia;
float fNota;
};
int iFitxategirikBada(const char sFitxIzen[]);
long liNotaMaximoarenIndizeaZehaztu(const char sFitxIzen[]);
long liNotaMinimoarenIndizeaZehaztu(const char sFitxIzen[]);
void IkasleBatenDatuakErakutsi(const char sFitxIzen[], long liNotaMaxNon);
int main()
{
char sFitxIzen[FITX_IZEN_MAX];
char sFitxIzenLaburra[FITX_IZEN_MAX];
long liNotaMaxNon;
long liNotaMinNon;
printf("Fitxategia existitzen da eta datuak ditu (adibidez C:\\Tokia\\Ikasleak.DAT)\n");
printf("''C:\\Tokia\\'' karpetako fitxategiaren izen laburra eman ezazu.\n");
printf("Adibidez, 'Datuak' izena: ");
scanf("%s", sFitxIzenLaburra);
getchar(); // Enter karakterea kentzeko
strcpy(sFitxIzen, "C:\\Tokia\\");
strcat(sFitxIzen, sFitxIzenLaburra);
strcat(sFitxIzen, ".dat");
printf("\n");
if (iFitxategirikBada(sFitxIzen) == 1)
{
printf("Notarik handiena zein ikasleri dagokio %s fitxategian?\n", sFitxIzen);
printf("Notarik txikiena zein ikasleri dagokio %s fitxategian?\n", sFitxIzen);
liNotaMaxNon = liNotaMaximoarenIndizeaZehaztu(sFitxIzen);
printf("\nIkaslerik onena...");
IkasleBatenDatuakErakutsi(sFitxIzen, liNotaMaxNon); // ikaslerik onena
liNotaMinNon = liNotaMinimoarenIndizeaZehaztu(sFitxIzen);
printf("\nIkaslerik txarrena...");
IkasleBatenDatuakErakutsi(sFitxIzen, liNotaMinNon); // ikaslerik txarrena
}
else
printf("'%s' fitxategia ez da existitzen, agur...", sFitxIzen);
printf("\nPrograma bukatzera doa. Edozein tekla sakatu! ");
getch(); // itxaron edozein tekla sakatu arte
printf("\n");
return 0;;
}
// funtzio honek fitxategi baten existentzia frogatzen du.
int iFitxategirikBada(const char sFitxIzen[])
{
FILE *f;
// Irakurketarako irekitze saiakera ("r" = read)
f = fopen(sFitxIzen, "rb");
// Fitxategirik ez balego fopen() funtzioak NULL itzuliko luke
if (f != NULL)
{
fclose(f); // fitxategia itxi baliabidwak askatzeko
return 1; // Itzuli 1 (true): fitxategia bada
}
// Fitxategirik ez balego fopen() funtzioak NULL itzuliko luke
return 0; // Itzuli 0 (false): fitxategia ez da existitzen
}
// hiru hasierakerak guztiz derrigorrezkoak dira:
// - konparaketak abiatzeko nota faltsu bat
// - nota faltsuari dagokion indize faltsua
// - maximoaren indizea finkatuko duen kontagailua
long liNotaMaximoarenIndizeaZehaztu(const char sFitxIzen[])
{
FILE *f;
struct tstFitxa stElem;
float fMaximoa = -1.0; // nota faltsua
long liMaximoaNon = -1; // indize faltsua
long liPos = 0; // kontagailuaren hasieraketa
f = fopen(sFitxIzen, "rb");
while (fread(&stElem, sizeof(struct tstFitxa), 1, f))
{
if (stElem.fNota > fMaximoa)
{
fMaximoa = stElem.fNota;
liMaximoaNon = liPos;
}
liPos++;
}
fclose(f);
return liMaximoaNon;
}
// hiru hasierakerak guztiz derrigorrezkoak dira:
// - konparaketak abiatzeko nota faltsu bat
// - nota faltsuari dagokion indize faltsua
// - minimoaren indizea finkatuko duen kontagailua
long liNotaMinimoarenIndizeaZehaztu(const char sFitxIzen[])
{
FILE *f;
struct tstFitxa stElem;
float fMinimoa = 11.0; // nota faltsua
long liMinimoaNon = -1; // indize faltsua
long liIndizea = 0; // kontagailuaren hasieraketa
f = fopen(sFitxIzen, "rb");
while (fread(&stElem, sizeof(struct tstFitxa), 1, f))
{
if (stElem.fNota < fMinimoa)
{
fMinimoa = stElem.fNota;
liMinimoaNon = liIndizea;
}
liIndizea++;
}
fclose(f);
return liMinimoaNon;
}
void IkasleBatenDatuakErakutsi(const char sFitxIzen[], long liNotaNon)
{
FILE *f;
struct tstFitxa stElem;
f = fopen(sFitxIzen, "rb");
fseek(f, liNotaNon*(long)sizeof(struct tstFitxa), SEEK_SET);
fread(&stElem, sizeof(struct tstFitxa), 1, f);
printf("\n%ld indizeko ikaslearen datuak hauek dira:\n", liNotaNon);
printf("Nor ---------> %s\n", stElem.sIzenDeiturak);
printf("Deialdia ----> %d\n", stElem.iDeialdia);
printf("Nota --------> %.2f\n", stElem.fNota);
fclose(f);
}
ZER DAKIDAN: Fitxategiak eta arrayak antzekoak dira datu-mota bereko hainbat elementu gordetzen dituztelako. Informazioa modu iraunkorrean mantentzen da fitxategietan; horregatik, nere informazioa array batean badago ikasi beharko dut arrayko informazioa fitxategi batera igarotzen (kontrakoa, fitxategitik arrayra ezagutzen dut).
ZER IKASIKO DUDAN: Array bateko elementu guztiak fitxategi batera eramaten ikasiko dut. Funtsean dakidan zerbait da, izan ere arrayaren prozesaketa mota bat da (Ariketa 45 | Algoritmoak arrayetan (1) adibidean ikusitako bezalakoa).
Datuak gordetzen dituen array bat daukagu. Esate baterako, estrukturen array bat eta bere informazioa estrukturen fitxategi batera igarotzea nahi da. Nolabait esateko, Ariketa 83 | Arraytik fitxategira: 8. algoritmoa ariketaren kontrakoa da.
Arraytik abiatuta fitxategi berri bat sortuko da arrayaren informazioarekin. Jarraian erakusten den programan, fitxategi batetik hasiko gara array bat elikatzeko, eta ondoren arraytik beste fitxategi berri bat lortuko dugu. Eskematikoki:
fitxategi_1 >>> array >>> fitxategi_2
Erakusten den programa honetan fitxategiaren existentzia frogatzen da programa nagusian, horren arabera:
Baldin eta fitxategia bada, liFitxategiElemKop() funtzioarei esker fitxategiak barneratzen dituen elementuen kopurua kalkulatzen da eta arrayaren GOIMUGA balioarekin alderatuko da. Konparaketaren arabera bi egoera hauek eman daitezke:
Fitxategiko elementuen kopurua handiegia da eta arrayaren neurria gainditzen du, ondorioz ez da informazioaren bihurketa egingo azalpen-mezu bat pantailaratuz
Fitxategiko elementuen kopurua arrayaren neurria baino txikiago da, ondoko urratsak beteko dira:
FitxategiArray() funtzioaren bitartez arraya elikatuko da fitxategi osoa prozesatuz
ArrayBatIkusi() ikusi funtzioari esker arrayaren informazioa pantailaratuko da
ArrayFitxategi() funtzioaren bitartez fitxategi berri bat sortuko da arrayaren informazioarekin
FitxategiaIkusi() ikusi funtzioari esker fitxategi berriaren informazioa pantailaratuko da
Baldin eta fitxategirik ez bada, mezu batez adierazten da
/* Ariketa-84_Fitxategien_8_algoritmoa: fitxategi >>> array >>> fitxategi */
// Fitxategia existitzen dela frogatu ondoren bere edukia erakusten da.
// Fitxategiaren elementuen kopurua kalkulatzen da eta alderatu egiten
// da arrayaren tamainarekin ziurtatzeko fitxategiko eduki osoa sartzen
// dela arrayan. Programaren funtzio esanguratsuenak bi hauek dira:
// - FitxategiArray()
// - ArrayFitxategi()
#include <stdio.h>
#include <string.h> // strcpy() eta strcat() funtzioetarako
#include <conio.h> // getch() funtziorako
#define sBIDEA "C:\\Tokia\\"
#define FITX_IZEN_MAX 120 // fitxategiaren izenerako 119 karaktere gehi null mugatzailea
#define DATU_IZEN_MAX 72 // ikaslearen izena gordetzeko 71 karaktere gehi null mugatzailea
#define BEHEMUGA 0
#define GOIMUGA 11 // 12 elementuentzat tokia
struct tstFitxa // struct definitzen ikasleen datuak gordetzeko
{
char sIzenDeiturak[DATU_IZEN_MAX];
int iDeialdia;
float fNota;
};
int iFitxategirikBada(const char *sFitxIzen);
long liFitxategiElemKop(const char *sFitxIzen);
void ElementuaErakutsi(const struct tstFitxa *stElem);
void ArrayBatIkusi(const struct tstFitxa astGela[], int iLuzera);
void FitxategiaIkusi(const char *sFitxIzen);
void FitxategiArray(struct tstFitxa astGela[],
int *iLuzera,
const char *sFitxIzen);
void ArrayFitxategi(const struct tstFitxa astGela[],
int iLuzera,
const char *sFitxIzen);
int main()
{
struct tstFitxa astGelaArray[GOIMUGA];
int iLuzeraLogiko;
long liElemKop;
char sFitxIzen[FITX_IZEN_MAX];
char sFitxIzenLaburra[FITX_IZEN_MAX];
char sFitxIzenBerri[FITX_IZEN_MAX];
printf("''C:\\Tokia\\'' karpetako fitxategiaren izen laburra eman ezazu.\n");
printf("Adibidez, 'Datuak' izena edo 'Ikasleak' izena: ");
gets(sFitxIzenLaburra);
strcpy(sFitxIzen, sBIDEA);
strcat(sFitxIzen, sFitxIzenLaburra);
strcat(sFitxIzen, ".dat");
printf("\n");
if (iFitxategirikBada(sFitxIzen) == 1)
{
printf("'%s' fitxategiaren informazioa arrayera igaroko da...\n", sFitxIzen);
FitxategiaIkusi(sFitxIzen);
printf("\n");
liElemKop = liFitxategiElemKop(sFitxIzen);
if (liElemKop > GOIMUGA+1)
{
printf("Fitxategiak %ld elementu ditu eta arrayaren posizioak %d dira\n", liElemKop, GOIMUGA+1);
printf("Fitxategiaren informazio guztia ezin da arrayan gorde\n");
}
else
{
FitxategiArray(astGelaArray, &iLuzeraLogiko, sFitxIzen);
printf("Bektorearen edukia:\n");
ArrayBatIkusi(astGelaArray, iLuzeraLogiko);
strcpy(sFitxIzenBerri, sBIDEA);
strcat(sFitxIzenBerri, "BERRIA---");
strcat(sFitxIzenBerri, sFitxIzenLaburra);
strcat(sFitxIzenBerri, ".dat");
printf("\n---\\%s\\---\n", sFitxIzenBerri);
printf("\n");
printf("Arrayaren informazioa '%s' fitxategian gordetzen...\n", sFitxIzenBerri);
ArrayFitxategi(astGelaArray, iLuzeraLogiko, sFitxIzenBerri);
FitxategiaIkusi(sFitxIzenBerri);
}
}
else
{
printf("'%s' fitxategia ez da existitzen, agur...", sFitxIzen);
}
printf("\nPrograma bukatzera doa. Edozein tekla sakatu! ");
getch(); // itxaron edozein tekla sakatu arte
printf("\n");
return 0;
}
// funtzio honek fitxategi baten existentzia frogatzen du.
int iFitxategirikBada(const char *sFitxIzen)
{
FILE *f;
// Irakurketarako irekitze saiakera ("r" = read)
f = fopen(sFitxIzen, "rb");
// Fitxategirik ez balego fopen() funtzioak NULL itzuliko luke
if (f != NULL)
{
fclose(f); // fitxategia itxi baliabidwak askatzeko
return 1; // Itzuli 1 (true): fitxategia bada
}
// Fitxategirik ez balego fopen() funtzioak NULL itzuliko luke
return 0; // Itzuli 0 (false): fitxategia ez da existitzen
}
// fitxategitik array batera datuak igarotzeko funtzioa
long liFitxategiElemKop(const char *sFitxIzen)
{
FILE *f;
long liZenbatElementu;
f = fopen(sFitxIzen, "rb");
fseek(f, 0L, SEEK_END);
liZenbatElementu = ftell(f) / sizeof(struct tstFitxa);
fclose(f);
return liZenbatElementu;
}
// fitxategiko edukia array batera kargatzeko funtzioa
void FitxategiArray(struct tstFitxa astGela[], int *iLuzera, const char *sFitxIzen)
{
FILE *f;
int iIndize;
f = fopen(sFitxIzen, "rb");
if (f == NULL) {
printf("Errorea '%s' fitxategia irekitzean 'FitxategiArray()' funtzioan \a\n", sFitxIzen);
*iLuzera = 0;
return;
}
iIndize = BEHEMUGA;
while (fread(&astGela[iIndize], sizeof(struct tstFitxa), 1, f) && iIndize <= GOIMUGA)
{
// printf("Arrayaren %d posizioan gorde da '%s'\n", iIndize, ardGela[iIndize].sIzenDeiturak);
iIndize++;
}
*iLuzera = iIndize;
fclose(f);
}
// arrayaren edukia pantailaratzeko funtzioa
void ArrayBatIkusi(const struct tstFitxa astGela[], int iLuzera)
{
for (int iKont = BEHEMUGA; iKont < iLuzera; iKont++)
{
printf("%d indizedun ikaslea >>> : %-20s : %d : %.2f :\n",
iKont,
astGela[iKont].sIzenDeiturak,
astGela[iKont].iDeialdia,
astGela[iKont].fNota);
}
}
// elementu baten datuak pantailaratzen dituen funtzioa
void ElementuaErakutsi(const struct tstFitxa *stElem)
{
printf("Ikaslea >>> | Nor: %-20s | Deialdia: %d | Nota: %.2f |\n",
stElem->sIzenDeiturak,
stElem->iDeialdia,
stElem->fNota);
}
// fitxategi bat pantailaratzeko funtzioa
void FitxategiaIkusi(const char *sFitxIzen)
{
FILE *f;
struct tstFitxa stElem;
f = fopen(sFitxIzen, "rb");
if (f == NULL)
{
printf("Errorea '%s' fitxategia irekitzean 'FitxategiaIkusi()' funtzioan \a\n", sFitxIzen);
return;
}
printf("'%s' fitxategiak duen edukia:\n", sFitxIzen);
while (fread(&stElem, sizeof(struct tstFitxa), 1, f) == 1)
{
ElementuaErakutsi(&stElem);
}
fclose(f);
}
// arrayaren edukia fitxategi batean gordetzeko funtzioa
void ArrayFitxategi(const struct tstFitxa astGela[], int iLuzera, const char *sFitxIzen)
{
FILE *f;
f = fopen(sFitxIzen, "wb");
if (f == NULL) {
printf("Errorea '%s' fitxategia irekitzean 'ArrayFitxategi()' funtzioan \a\n", sFitxIzen);
return;
}
for (int i = BEHEMUGA; i < iLuzera; i++)
{
fwrite(&astGela[i], sizeof(struct tstFitxa), 1, f);
}
fclose(f);
}
ZER DAKIDAN: Fitxategiak eta arrayak antzekoak dira datu-mota bereko hainbat elementu gordetzen dituztelako. Algoritmo batzuk errazagoak dira arrayetan fitxategietan baino; horregatik, nere informazioa fitxategi batean badago ikasi beharko dut fitxategiko informazioa array batera igarotzen (kontrakoa, arraytik fitxategira ikasi beharko dut ere).
ZER IKASIKO DUDAN: Fitxategi bateko elementu guztiak array batera eramaten ikasiko dut. Funtsean dakidan zerbait da, izan ere fitxategiaren prozesaketa mota bat da (Ariketa 77 | Fitxategi osoa prozesatu: 2. algoritmoa adibidean ikusitako bezalakoa).
Datuak gordetzen dituen fitxategi bat daukagu. Esate baterako, estrukturen fitxategi bat daukagu eta bere informazioa estrukturen array batera igarotzea nahi da.
Fitxategitik arrayra informazioa eraman aurretik, frogatu beharra dago fitxategiko elementuen kopurua ez dela handiagoa arrayaren neurria baino.
Erakusten den programa honetan fitxategiaren existentzia frogatzen da programa nagusian, horren arabera:
Baldin eta fitxategia bada, liFitxategiElemKop() funtzioarei esker fitxategiak barneratzen dituen elementuen kopurua kalkulatzen da eta arrayaren GOIMUGA balioarekin alderatuko da. Konparaketaren arabera bi egoera hauek eman daitezke:
Fitxategiko elementuen kopurua handiegia da eta arrayaren neurria gainditzen du, ondorioz ez da informazioaren bihurketa egingo azalpen-mezu bat pantailaratuz
Fitxategiko elementuen kopurua arrayaren neurria baino txikiago da, ondoko urratsak beteko dira:
FitxategiArray() funtzioaren bitartez arraya elikatuko da fitxategi osoa prozesatuz
ArrayBatIkusi() ikusi funtzioari esker arrayaren informazioa pantailaratuko da
Baldin eta fitxategirik ez bada, mezu batez adierazten da
/* Ariketa-83_Fitxategien_8_algoritmoa: fitxategi >>> array */
// Fitxategia existitzen dela frogatu ondoren bere edukia erakusten da.
// Fitxategiaren elementuen kopurua kalkulatzen da eta alderatu egiten
// da arrayaren tamainarekin ziurtatzeko fitxategiko eduki osoa sartzen
// dela arrayan. Programaren funtzio esanguratsuena: FitxategiArray().
#include <stdio.h>
#include <string.h> // strcpy() eta strcat() funtzioetarako
#include <conio.h> // getch() funtziorako
#define sBIDEA "C:\\Tokia\\"
#define FITX_IZEN_MAX 120 // fitxategiaren izenerako 119 karaktere gehi null mugatzailea
#define DATU_IZEN_MAX 72 // ikaslearen izena gordetzeko 71 karaktere gehi null mugatzailea
#define BEHEMUGA 0
#define GOIMUGA 11 // 12 elementuentzat tokia
struct tstFitxa // struct definitzen ikasleen datuak gordetzeko
{
char sIzenDeiturak[DATU_IZEN_MAX];
int iDeialdia;
float fNota;
};
int iFitxategirikBada(const char *sFitxIzen);
long liFitxategiElemKop(const char *sFitxIzen);
void FitxategiArray(struct tstFitxa astGela[],
int *iLuzera,
const char *sFitxIzen);
void ArrayBatIkusi(const struct tstFitxa astGela[], int iLuzera);
void FitxategiaIkusi(const char *sFitxIzen);
int main()
{
struct tstFitxa astGela[GOIMUGA]; // array aldagaia
int iLuzeraLogiko = 0;
char sFitxIzen[FITX_IZEN_MAX];
char sFitxIzenLaburra[FITX_IZEN_MAX];
long liElemKop;
printf("Fitxategia existitzen da eta datuak ditu\n(adibidez C:\\Tokia\\Ikasleak.dat)\n\n");
printf("Fitxategiaren izen laburra eman (adibidez 'Ikasleak'): ");
gets(sFitxIzenLaburra);
strcpy(sFitxIzen, sBIDEA);
strcat(sFitxIzen, sFitxIzenLaburra);
strcat(sFitxIzen, ".dat");
if (iFitxategirikBada(sFitxIzen) == 1)
{
printf("'%s' fitxategiaren informazioa arrayera igaroko da...\n", sFitxIzen);
FitxategiaIkusi(sFitxIzen);
printf("\n");
liElemKop = liFitxategiElemKop(sFitxIzen);
if (liElemKop > GOIMUGA+1)
{
printf("Fitxategiak %ld elementu ditu eta arrayaren posizioak %d dira\n", liElemKop, GOIMUGA+1);
printf("Fitxategiaren informazio guztia ezin da arrayan gorde\n");
}
else
{
FitxategiArray(astGela, &iLuzeraLogiko, sFitxIzen);
printf("\nBektorearen edukia (datuetan ez da aldaketarik egin):\n");
ArrayBatIkusi(astGela, iLuzeraLogiko);
}
}
else
{
printf("'%s' fitxategia ez da existitzen, agur...", sFitxIzen);
}
printf("\nPrograma bukatzera doa. Edozein tekla sakatu! ");
getch(); // itxaron edozein tekla sakatu arte
printf("\n");
return 0;
}
// funtzio honek fitxategi baten existentzia frogatzen du.
int iFitxategirikBada(const char *sFitxIzen)
{
FILE *f;
// Irakurketarako irekitze saiakera ("r" = read)
f = fopen(sFitxIzen, "rb");
// Fitxategirik ez balego fopen() funtzioak NULL itzuliko luke
if (f != NULL)
{
fclose(f); // fitxategia itxi baliabidwak askatzeko
return 1; // Itzuli 1 (true): fitxategia bada
}
// Fitxategirik ez balego fopen() funtzioak NULL itzuliko luke
return 0; // Itzuli 0 (false): fitxategia ez da existitzen
}
// fitxategi bateko elementuen kopurua itzultzen duen funtzioa
long liFitxategiElemKop(const char *sFitxIzen)
{
FILE *f;
long liZenbatElementu;
f = fopen(sFitxIzen, "rb");
fseek(f, 0, SEEK_END);
liZenbatElementu = ftell(f) / sizeof(struct tstFitxa);
fclose(f);
return liZenbatElementu;
}
// fitxategitik array batera datuak igarotzeko funtzioa
void FitxategiArray(struct tstFitxa astGela[], int *iLuzera, const char *sFitxIzen)
{
FILE *f;
f = fopen(sFitxIzen, "rb");
*iLuzera = BEHEMUGA;
// elementu guztientzat arrayan tokia dagoela ez bada konprobatu GOIMUGA aldagaia beharko da
// while (fread(&astGela[*iLuzera], sizeof(struct tstFitxa), 1, f) && *iLuzera <= GOIMUGA)
while (fread(&astGela[*iLuzera], sizeof(struct tstFitxa), 1, f)) // badakigulako elementu guztientzat
{ // tokia dagoela arrayan
printf("'%s' gordeta arrayaren %d posizioan\n", astGela[*iLuzera].sIzenDeiturak, *iLuzera);
(*iLuzera)++; // edo *iLuzera=*iLuzera+1;
}
fclose(f);
}
// arrayaren edukia pantailaratzeko funtzioa
void ArrayBatIkusi(const struct tstFitxa astGela[], int iLuzera)
{
for (int iKont = BEHEMUGA; iKont < iLuzera; iKont++)
{
printf("%d indizedun ikaslea >>> : %-20s : %d : %.2f :\n",
iKont,
astGela[iKont].sIzenDeiturak,
astGela[iKont].iDeialdia,
astGela[iKont].fNota);
}
}
// fitxategiaren prozesaketa osoa
void FitxategiaIkusi(const char *sFitxIzen)
{
FILE *f;
struct tstFitxa stElem;
int iPosizioa;
// fitxategi bitarra irakurketa moduan ireki
f = fopen(sFitxIzen, "rb");
// fitxategiko datuak banan-banan irakurri eta pantailan erakutsi
iPosizioa = 0;
while (fread(&stElem, sizeof(struct tstFitxa), 1, f)) // irakurtzerik dagoen bitartean...
{
printf("%d. ikaslearen datuak: | %-20s | %d | %.2f |\n",
iPosizioa, stElem.sIzenDeiturak, stElem.iDeialdia, stElem.fNota);
iPosizioa++;
}
fclose(f);
}
ZER DAKIDAN: Fitxategiak zer diren badakit, eta fitxategiak irekitzeko w, r eta a markak erabili behar ditudala badakit.
ZER IKASIKO DUDAN: Elementu berri bat fitxategiaren bukaeran idazteko, fitxategia irekitzerakoan a+ marka erabiliko dut.
Datuak gordetzen dituen fitxategi bat daukagu. Esate baterako, estrukturen fitxategi bat daukagu eta elementu berri bat gehitu nahi da fitxategiaren bukaeran. Algoritmoa asko errazten da fitxategia a+ markarekin (open for reading and appending) irekitzen bada.
...
f = fopen(sFitxIzen, "a+b"); // fitxategia irakurtzeko eta bukaeran idazteko moduan ireki
DatuakEskuratu(&stElem); // elementu berriaren eremuak teklatuz irakurri
fwrite(&stElem, sizeof(struct tstFitxa), 1, f); // fitxategiaren bukaeran idatzi
...
Erakusten den programa honetan fitxategiaren existentzia frogatzen da programa nagusian, horren arabera:
Baldin eta fitxategia bada, ondoko bi lanak burutuko dira:
Zehaztutako fitxategiaren edukia pantailaratu
Datuak teklatuz irakurri: izen bat, deialdi bat eta nota bat
a+ markarekin ireki fitxategia eta elementu berria idatzi
Baldin eta fitxategirik ez bada, programa amaitu aurretik mezu batez adierazten da
/* Ariketa-79_Fitxategien_7_algoritmoa: elementu berri bat gehitu */
// Fitxategiaren izena eman ondoren elementu berri baten gehiketa
// egingo da, horretarako fitxategia irekitzean "a" marka jarriko
// zaio, honela: f = fopen(sFitxIzen, "a+b");
// Hori dela eta, idazketak fitxategiaren bukaeran gauzatuko dira.
#include <stdio.h>
#include <string.h> // strcpy() eta strcat() funtzioetarako
#include <conio.h> // getche() eta getch() funtzioetarako
#define sBIDEA "C:\\Tokia\\"
#define FITX_IZEN_MAX 120 // fitxategiaren izenerako 119 karaktere gehi null mugatzailea
#define DATU_IZEN_MAX 72 // ikaslearen izena gordetzeko 71 karaktere gehi null mugatzailea
struct tstFitxa
{
char sIzenDeiturak[DATU_IZEN_MAX];
int iDeialdia;
float fNota;
};
int iFitxategirikBada(const char sFitxIzen[]);
void DatuGuztiakErakutsi(const char sFitxIzen[]);
void DatuakEskuratu(struct tstFitxa *stElementua);
void Gehiketa(const char sFitxIzen[]);
int main()
{
char sFitxIzenLaburra[FITX_IZEN_MAX];
char sFitxIzen[FITX_IZEN_MAX];
printf("Fitxategiaren izen laburra eman (adibidez 'Ikasleak'): ");
gets(sFitxIzenLaburra);
strcpy(sFitxIzen, "C:\\Tokia\\");
strcat(sFitxIzen, sFitxIzenLaburra);
strcat(sFitxIzen, ".dat");
if (iFitxategirikBada(sFitxIzen) == 1)
{
printf("====================================================================\n");
DatuGuztiakErakutsi(sFitxIzen);
printf("====================================================================\n");
Gehiketa(sFitxIzen);
printf("#####################################################################\n");
DatuGuztiakErakutsi(sFitxIzen);
printf("#####################################################################\n");
}
else
{
printf("'%s' fitxategia ez da existitzen, agur...", sFitxIzen);
}
printf("\n\nPrograma bukatzera doa. Edozein tekla sakatu! ");
getch(); // itxaron edozein tekla sakatu arte
printf("\n");
return 0;
}
// Funtzio honek fitxategi baten existentzia frogatzen du.
int iFitxategirikBada(const char sFitxIzen[])
{
FILE *f;
// Irakurketarako irekitze saiakera ("r" = read)
f = fopen(sFitxIzen, "rb");
// Fitxategirik ez balego fopen() funtzioak NULL itzuliko luke
if (f != NULL)
{
fclose(f); // fitxategia itxi baliabidwak askatzeko
return 1; // Itzuli 1 (true): fitxategia bada
}
// Fitxategirik ez balego fopen() funtzioak NULL itzuliko luke
return 0; // Itzuli 0 (false): fitxategia ez da existitzen
}
// datuak erabiltzailearengandik biltzeko funtzioa
void DatuakEskuratu(struct tstFitxa *stElementua)
{
printf("Ikasle berriaren izen deiturak eman: ");
gets(stElementua->sIzenDeiturak);
printf("Deialdia eman: ");
scanf("%d", &stElementua->iDeialdia);
printf("Nota eman: ");
scanf("%f", &stElementua->fNota);
getchar(); // Enter karakterea kentzeko
}
// fitxategiaren bukaeran datu berri bat gehitzeko funtzioa
void Gehiketa(const char sFitxIzen[])
{
FILE *f;
struct tstFitxa stElem;
fpos_t Posizioa;
f = fopen(sFitxIzen, "a+b"); // fitxategia irakurtzeko eta bukaeran idazteko moduan ireki
if (f == NULL)
{
printf("Errorea '%s' fitxategia irekitzean 'Gehiketa()' funtzioan \a\n", sFitxIzen);
return;
}
fgetpos(f, &Posizioa);
printf("-----fopen(sFitxIzen,\"a+b\") egin ondoren, posizioa=%d\n", (int)Posizioa);
DatuakEskuratu(&stElem);
fwrite(&stElem, sizeof(struct tstFitxa), 1, f); // fitxategian idatzi
fgetpos(f, &Posizioa);
printf("-----fwrite() eta gero, posizioa=%d\n", (int)Posizioa);
printf("-----Elementu bakoitzak %ld byte ditu\n", (long)sizeof(stElem));
fclose(f); // fitxategia itxi
}
// fitxategiaren prozesaketa osoa
void DatuGuztiakErakutsi(const char sFitxIzen[])
{
FILE *f;
struct tstFitxa stElem;
int iPosizioa;
// fitxategi bitarra irakurketa moduan ireki
f = fopen(sFitxIzen, "rb");
// fitxategiko datuak banan-banan irakurri eta pantailan erakutsi
iPosizioa = 0;
while (fread(&stElem, sizeof(struct tstFitxa), 1, f) == 1) // irakurtzerik dagoen bitartean...
{
printf("%d. ikaslearen datuak: | %-20s | %d | %.2f |\n",
iPosizioa, stElem.sIzenDeiturak, stElem.iDeialdia, stElem.fNota);
iPosizioa++;
}
fclose(f);
}
ZER DAKIDAN: Fitxategiko elementu jakin baten aldaketa nola burutzen den badakit.
ZER IKASIKO DUDAN: Fitxategiko elementu guztiak aldatzeko bi algoritmo ikasiko ditut: batean egitura laguntzailerik (array edo fitxategi) ez da erabiltzen, eta, beste algoritmoan, fitxategi laguntzaile bati esker helburuko fitxategiaren elementu guztiak aldatuko ditut.
Datuak gordetzen dituen fitxategi bat daukagu. Esate baterako, estrukturen fitxategi bat daukagu eta elementu guztien eremu bat (adibidez iDeialdia) aldatu nahi dugu.
Estrukturen fitxategi bat daukagu eta elementu guztien iDeialdia eremua aldatu nahi dugu bestelako egitura laguntzailerik gabe. Elementu bakoitzeko irakurri-aldatu-idatzi sekuentzia bete beharko da.
...
fread(&stElem, sizeof(struct tstFitxa), 1, f); // elementu bat irakurri
stElem.iDeialdia++; // deialdia inkrementatu
fseek(f, (-1)*(long)sizeof(struct tstFitxa), SEEK_CUR); // fitxategian posizio bat atzera
fwrite(&stElem, sizeof(struct tstFitxa), 1, f); // fitxategian idatzi
fseek(f, 0L, SEEK_CUR); // uneko posizioan kokatu
...
Erakusten den programa honetan fitxategiaren existentzia frogatzen da programa nagusian, horren arabera:
Baldin eta fitxategia bada, fitxategi osoaren edukia pantailaratzen da hiru modu desberdinetan eta ondoren fitxategiaren elementu guztietan aldaketa burutuko da egitura laguntzailerik gabe
Fitxategirik ez bada, fitxategia sortu eta datuz beteko da. Ondoren, lehen bezala, fitxategi osoaren edukia pantailaratzen da hiru modu desberdinetan eta jarraian fitxategiaren elementu guztietan aldaketa burutuko da egitura laguntzailerik gabe
/* Ariketa-81_Fitxategien_6a_algoritmoa: elementu guztiak aldatu array
edo fitxategi laguntzailerik gabe */
#include <stdio.h>
#include <string.h> // strcpy() eta strcat() funtzioetarako
#include <ctype.h> // toupper() funtziorako
#include <conio.h> // getch() funtziorako
#define sBIDEA "C:\\Tokia\\"
#define FITX_IZEN_MAX 120 // fitxategiaren izenerako 119 karaktere gehi null mugatzailea
#define DATU_IZEN_MAX 72 // ikaslearen izena gordetzeko 71 karaktere gehi null mugatzailea
struct tstFitxa
{
char sIzenDeiturak[DATU_IZEN_MAX];
int iDeialdia;
float fNota;
};
int iFitxategirikBada(const char sFitxIzen[]);
void DatuakBiltegitu(const char sFitxIzen[]);
void DatuGuztiakErakutsi_0(const char sFitxIzen[]);
void DatuGuztiakErakutsi_1(const char sFitxIzen[]);
void DatuGuztiakBirritanIkusi(const char sFitxIzen[]);
void DatuGuztiakAldatu(const char sFitxIzen[]);
int main()
{
char sFitxIzenLaburra[FITX_IZEN_MAX];
char sFitxIzen[FITX_IZEN_MAX];
printf("Fitxategiaren izen laburra eman (adibidez 'Ikasleak' edo 'Datuak'): ");
gets(sFitxIzenLaburra);
strcpy(sFitxIzen, "C:\\Tokia\\");
strcat(sFitxIzen, sFitxIzenLaburra);
strcat(sFitxIzen, ".dat");
if (iFitxategirikBada(sFitxIzen) == 1)
{
printf("'%s' fitxategia existitzen da, bere edukia erakutsi...\n\n", sFitxIzen);
}
else
{
printf("'%s' fitxategia ez da existitzen, sortu eta erakutsi...\n\n", sFitxIzen);
DatuakBiltegitu(sFitxIzen);
}
printf("----DatuGuztiakErakutsi_0--------------------------------------------\n");
DatuGuztiakErakutsi_0(sFitxIzen);
printf("---------------------------------------------------------------------\n\n");
printf("----DatuGuztiakErakutsi_1--------------------------------------------\n");
DatuGuztiakErakutsi_1(sFitxIzen);
printf("---------------------------------------------------------------------\n\n");
printf("----DatuGuztiakBirritanIkusi-----------------------------------------\n");
DatuGuztiakBirritanIkusi(sFitxIzen);
printf("---------------------------------------------------------------------\n\n");
printf("\nIkasleen deialdi kopurua eguneratzen '%s' fitxategian\n", sFitxIzen);
printf("inolako egitura lagunzailerik gabe. Aurrera egiteko, edozein tekla sakatu! ");
getch(); // itxaron edozein tekla sakatu arte
printf("\n\n");
DatuGuztiakAldatu(sFitxIzen);
printf("\n");
printf("----DatuGuztiakErakutsi_0--------------------------------------------\n");
DatuGuztiakErakutsi_0(sFitxIzen);
printf("---------------------------------------------------------------------\n\n");
printf("\nPrograma bukatzera doa. Edozein tekla sakatu! ");
getch(); // itxaron edozein tekla sakatu arte
printf("\n");
return 0;
}
// Funtzio honek fitxategi baten existentzia frogatzen du.
int iFitxategirikBada(const char sFitxIzen[])
{
FILE *f;
// Irakurketarako irekitze saiakera ("r" = read)
f = fopen(sFitxIzen, "rb");
// Fitxategirik ez balego fopen() funtzioak NULL itzuliko luke
if (f != NULL)
{
fclose(f); // fitxategia itxi baliabidwak askatzeko
return 1; // Itzuli 1 (true): fitxategia bada
}
// Fitxategirik ez balego fopen() funtzioak NULL itzuliko luke
return 0; // Itzuli 0 (false): fitxategia ez da existitzen
}
// fitxategiaren sortu eta datuz bete
void DatuakBiltegitu(const char sFitxIzen[])
{
FILE *f;
struct tstFitxa stElem;
long lPosizioa;
char cErantz;
// fitxategi bitarra sortu idazketarako
f = fopen(sFitxIzen, "wb");
if (f == NULL)
{
printf("Errorea '%s' fitxategia irekitzean 'DatuakBiltegitu()' funtzioan \a\n", sFitxIzen);
}
else
{
lPosizioa = -1;
do
{
lPosizioa++;
printf("Eman %ld posizioko ikaslearen izen-deiturak: ", lPosizioa);
fgets(stElem.sIzenDeiturak, sizeof(stElem.sIzenDeiturak), stdin);
stElem.sIzenDeiturak[strcspn(stElem.sIzenDeiturak, "\n")] = 0; // lerro-berri karakterea kendu
printf("Eman ikaslearen deialdia: ");
scanf("%d", &stElem.iDeialdia);
printf("Eman ikaslearen nota: ");
scanf("%f", &stElem.fNota);
getchar(); // lerro-berri karakterea kontsumitu
printf("---Ikaslearen datuak: | %-20s | %d | %.2f |---\n\n", stElem.sIzenDeiturak, stElem.iDeialdia, stElem.fNota);
// datuak banan-banan fitxategian idatzi
fwrite(&stElem, sizeof(struct tstFitxa), 1, f);
printf("Gehiagorik? (B/E) ");
cErantz = getch();
cErantz = toupper(cErantz);
printf("%c\n", cErantz);
} while (cErantz != 'E');
fclose(f);
}
printf("\n");
}
// fitxategiaren prozesaketa osoa
void DatuGuztiakErakutsi_0(const char sFitxIzen[])
{
FILE *f;
struct tstFitxa stElem;
int iPosizioa;
// fitxategi bitarra irakurketa moduan ireki
f = fopen(sFitxIzen, "rb");
printf("++++while (fread(&stElem, sizeof(struct tstFitxa), 1, f))++++\n");
printf("---------------------------------------------------------------------\n");
// fitxategiko datuak banan-banan irakurri eta pantailan erakutsi
iPosizioa = 0;
while (fread(&stElem, sizeof(struct tstFitxa), 1, f)) // irakurtzerik dagoen bitartean...
{
printf("%d. ikaslearen datuak: | %-20s | %d | %.2f |\n",
iPosizioa, stElem.sIzenDeiturak, stElem.iDeialdia, stElem.fNota);
iPosizioa++;
}
fclose(f);
}
// fitxategiaren prozesaketa osoa
void DatuGuztiakErakutsi_1(const char sFitxIzen[])
{
FILE *f;
struct tstFitxa stElem;
int iKont;
long liZenbatBit;
f = fopen(sFitxIzen, "rb");
fseek(f, 0L, SEEK_END); // fitxategiaren bukaeran kokatu
liZenbatBit = ftell(f); // fitxategiaren tamaina kalkulatu
fseek(f, 0L, SEEK_SET); // fitxategiaren hasieran kokatu
// elementu guztiak prozesatu...
printf("++++for behemuga=1 goimuga=%d+++++++++++++++++++++++++++++++++++++++++\n", (int)liZenbatBit/sizeof(struct tstFitxa));
printf("---------------------------------------------------------------------\n");
for (iKont = 1; iKont <= liZenbatBit/sizeof(struct tstFitxa); iKont++)
{
fread(&stElem, sizeof(struct tstFitxa), 1, f);
printf("##### %d. ikaslearen datuak: | %-20s | %d | %.2f |\n",
iKont, stElem.sIzenDeiturak, stElem.iDeialdia, stElem.fNota);
}
fclose(f);
}
// fitxategi osoa prozesatzeko funtzioa
void DatuGuztiakBirritanIkusi(const char sFitxIzen[])
{
FILE *f;
struct tstFitxa stElem;
int iKont;
long liZenbatBit;
f = fopen(sFitxIzen, "rb");
fseek(f, 0L, SEEK_END); // fitxategiaren bukaeran kokatu
liZenbatBit = ftell(f); // fitxategiaren tamaina eskuratu
fseek(f, 0L, SEEK_SET); // fitxategiaren hasieran kokatu
// elementu guztiak prozesatu...
for (iKont = 1; iKont <= liZenbatBit/sizeof(struct tstFitxa); iKont++)
{
fread(&stElem, sizeof(struct tstFitxa), 1, f); // elementu bat irakurri eta...
printf("(1) %d. ikaslearen datuak: | %-20s | %d | %.2f |\n",
iKont, stElem.sIzenDeiturak, stElem.iDeialdia, stElem.fNota);
fseek(f, (-1)*(long)sizeof(struct tstFitxa), SEEK_CUR); // fitxategian posizio bat atzera
fread(&stElem, sizeof(struct tstFitxa), 1, f); // elementu bat irakurri eta...
printf("(2) %d. ikaslearen datuak: | %-20s | %d | %.2f |\n",
iKont, stElem.sIzenDeiturak, stElem.iDeialdia, stElem.fNota);
}
fclose(f);
}
// fitxategi osoa prozesatzeko funtzioa
void DatuGuztiakAldatu(const char sFitxIzen[])
{
FILE *f;
struct tstFitxa stElem;
int iKont;
long liZenbatBit;
f = fopen(sFitxIzen, "r+b");
fseek(f, 0L, SEEK_END); // fitxategiaren bukaeran kokatu
liZenbatBit = ftell(f); // fitxategiaren tamaina kalkulatu
fseek(f, 0L, SEEK_SET); // fitxategiaren hasieran kokatu
// elementu guztiak prozesatu...
for (iKont = 1; iKont <= liZenbatBit/sizeof(struct tstFitxa); iKont++)
{
fread(&stElem, sizeof(struct tstFitxa), 1, f); // elementu bat irakurri
stElem.iDeialdia++; // deialdia inkrementatu
fseek(f, (-1)*(long)sizeof(struct tstFitxa), SEEK_CUR); // fitxategian posizio bat atzera
fwrite(&stElem, sizeof(struct tstFitxa), 1, f); // fitxategian idatzi
fseek(f, 0L, SEEK_CUR); // ez dago soberan // uneko posizioan kokatu
}
fclose(f);
}
Estrukturen fitxategi bat daukagu eta elementu guztien iDeialdia eremua aldatu nahi dugu fitxategi laguntzaile bat erabiliz. Oraindik rename() funtzioa eta remove() funtzioa ezagutzen ez ditugulako, aldaketa bi urratsetan burutuko dugu:
Elementu guztiak prozesatu laguntzailea elikatuz. Elementu bakoitzeko:
fitxategitik_irakurri
memorian_aldatu
laguntzailean_idatzi
Helburuko fitxategiaren elementu guztiak zapaldu. Elementu bakoitzeko:
laguntzailetik_irakurri
fitxategian_idatzi
Erakusten den programa honetan fitxategiaren existentzia frogatzen da programa nagusian, horren arabera:
Baldin eta fitxategia bada, fitxategi osoaren edukia pantailaratzen da hiru modu desberdinetan eta ondoren fitxategiaren elementu guztietan aldaketa burutuko da fitxategi laguntzaile bat erabiliz
Fitxategirik ez bada, fitxategia sortu eta datuz beteko da. Ondoren, lehen bezala, fitxategi osoaren edukia pantailaratzen da hiru modu desberdinetan eta jarraian fitxategiaren elementu guztietan aldaketa burutuko fitxategi laguntzaile bati esker
/* Ariketa-81_Fitxategien_6b_algoritmoa: elementu guztiak aldatu
fitxategi laguntzaile batez */
// Ariketa honetan rename() eta remove() funtzioak erabil daitezke.
#include <stdio.h>
#include <ctype.h> // toupper() funtziorako
#include <string.h> // strcpy() eta strcat() funtzioetarako
#include <conio.h> // getche() eta getch() funtzioetarako
#define sBIDEA "C:\\Tokia\\"
#define sLAGUNTZAILEA "C:\\Tokia\\FitxategiLaguntzailea.dat"
#define FITX_IZEN_MAX 120 // fitxategiaren izenerako 119 karaktere gehi null mugatzailea
#define DATU_IZEN_MAX 72 // ikaslearen izena gordetzeko 71 karaktere gehi null mugatzailea
struct tstFitxa
{
char sIzenDeiturak[DATU_IZEN_MAX];
int iDeialdia;
float fNota;
};
int iFitxategirikBada(const char sFitxIzen[]);
void DatuakBiltegitu(const char sFitxIzen[]);
void DatuGuztiakErakutsi_0(const char sFitxIzen[]);
void DatuGuztiakErakutsi_1(const char sFitxIzen[]);
void DatuGuztiakBirritanIkusi(const char sFitxIzen[]);
void DatuGuztiakAldatu(const char sFitxIzen[]);
int main()
{
char sFitxIzenLaburra[FITX_IZEN_MAX];
char sFitxIzen[FITX_IZEN_MAX];
printf("Fitxategiaren izen laburra eman (adibidez 'Ikasleak' edo 'Datuak'): ");
gets(sFitxIzenLaburra);
strcpy(sFitxIzen, "C:\\Tokia\\");
strcat(sFitxIzen, sFitxIzenLaburra);
strcat(sFitxIzen, ".dat");
if (iFitxategirikBada(sFitxIzen) == 1)
{
printf("'%s' fitxategia existitzen da, bere edukia erakutsi...\n\n", sFitxIzen);
}
else
{
printf("'%s' fitxategia ez da existitzen, sortu eta erakutsi...\n\n", sFitxIzen);
DatuakBiltegitu(sFitxIzen);
}
printf("----DatuGuztiakErakutsi_0---------------------------------------------------\n");
DatuGuztiakErakutsi_0(sFitxIzen);
printf("----------------------------------------------------------------------------\n\n");
printf("----DatuGuztiakErakutsi_1---------------------------------------------------\n");
DatuGuztiakErakutsi_1(sFitxIzen);
printf("----------------------------------------------------------------------------\n\n");
printf("----DatuGuztiakBirritanIkusi------------------------------------------------\n");
DatuGuztiakBirritanIkusi(sFitxIzen);
printf("----------------------------------------------------------------------------\n\n");
printf("\nIkasleen deialdi kopurua eguneratzen '%s' fitxategian\n", sFitxIzen);
printf("beste '%s' delako fitxategi bat erabiliz\n", sLAGUNTZAILEA);
printf("Aurrera egiteko, edozein tekla sakatu!");
getch(); // itxaron edozein tekla sakatu arte
printf("\n\n");
DatuGuztiakAldatu(sFitxIzen);
printf("\n");
printf("----DatuGuztiakErakutsi_0---------------------------------------------------\n");
DatuGuztiakErakutsi_0(sFitxIzen);
printf("----------------------------------------------------------------------------\n\n");
printf("\nPrograma bukatzera doa. Edozein tekla sakatu! ");
getch(); // itxaron edozein tekla sakatu arte
printf("\n");
return 0;
}
// Funtzio honek fitxategi baten existentzia frogatzen du.
int iFitxategirikBada(const char sFitxIzen[])
{
FILE *f;
// Irakurketarako irekitze saiakera ("r" = read)
f = fopen(sFitxIzen, "rb");
// Fitxategirik ez balego fopen() funtzioak NULL itzuliko luke
if (f != NULL)
{
fclose(f); // fitxategia itxi baliabidwak askatzeko
return 1; // Itzuli 1 (true): fitxategia bada
}
// Fitxategirik ez balego fopen() funtzioak NULL itzuliko luke
return 0; // Itzuli 0 (false): fitxategia ez da existitzen
}
// fitxategiaren sortu eta datuz bete
void DatuakBiltegitu(const char sFitxIzen[])
{
FILE *f;
struct tstFitxa stElem;
long lPosizioa;
char cErantz;
// fitxategi bitarra sortu idazketarako
f = fopen(sFitxIzen, "wb");
if (f == NULL)
{
printf("Errorea '%s' fitxategia irekitzean 'DatuakBiltegitu()' funtzioan \a\n", sFitxIzen);
}
else
{
lPosizioa = -1;
do
{
lPosizioa++;
printf("Eman %ld posizioko ikaslearen izen-deiturak: ", lPosizioa);
gets(stElem.sIzenDeiturak);
printf("Eman ikaslearen deialdia: ");
scanf("%d", &stElem.iDeialdia);
printf("Eman ikaslearen nota: ");
scanf("%f", &stElem.fNota);
getchar(); // lerro-berri karakterea kontsumitu
printf("---Ikaslearen datuak: | %-20s | %d | %.2f |---\n\n", stElem.sIzenDeiturak, stElem.iDeialdia, stElem.fNota);
// datuak banan-banan fitxategian idatzi
fwrite(&stElem, sizeof(struct tstFitxa), 1, f);
printf("Gehiagorik? (B/E) ");
cErantz = getch();
cErantz = toupper(cErantz);
printf("%c\n", cErantz);
} while (cErantz != 'E');
fclose(f);
}
printf("\n");
}
// fitxategiaren prozesaketa osoa
void DatuGuztiakErakutsi_0(const char sFitxIzen[])
{
FILE *f;
struct tstFitxa stElem;
int iPosizioa;
// fitxategi bitarra irakurketa moduan ireki
f = fopen(sFitxIzen, "rb");
printf("++++while (fread(&stElem, sizeof(struct tstFitxa), 1, f))+++++++++++++++++++\n");
printf("----------------------------------------------------------------------------\n");
// fitxategiko datuak banan-banan irakurri eta pantailan erakutsi
iPosizioa = 0;
while (fread(&stElem, sizeof(struct tstFitxa), 1, f)) // irakurtzerik dagoen bitartean...
{
printf("%d. ikaslearen datuak: | %-20s | %d | %.2f |\n",
iPosizioa, stElem.sIzenDeiturak, stElem.iDeialdia, stElem.fNota);
iPosizioa++;
}
fclose(f);
}
// fitxategiaren prozesaketa osoa
void DatuGuztiakErakutsi_1(const char sFitxIzen[])
{
FILE *f;
struct tstFitxa stElem;
int iKont;
long liZenbatBit;
f = fopen(sFitxIzen, "rb");
fseek(f, 0L, SEEK_END); // fitxategiaren bukaeran kokatu
liZenbatBit = ftell(f); // fitxategiaren tamaina kalkulatu
fseek(f, 0L, SEEK_SET); // fitxategiaren hasieran kokatu
// elementu guztiak prozesatu...
printf("++++for behemuga=1 goimuga=%d++++++++++++++++++++++++++++++++++++++++++++++++\n", (int)liZenbatBit/sizeof(struct tstFitxa));
printf("----------------------------------------------------------------------------\n");
for (iKont = 1; iKont <= liZenbatBit/sizeof(struct tstFitxa); iKont++)
{
fread(&stElem, sizeof(struct tstFitxa), 1, f);
printf("##### %d. ikaslearen datuak: | %-20s | %d | %.2f |\n",
iKont, stElem.sIzenDeiturak, stElem.iDeialdia, stElem.fNota);
}
fclose(f);
}
// fitxategi osoa prozesatzeko funtzioa
void DatuGuztiakBirritanIkusi(const char sFitxIzen[])
{
FILE *f;
struct tstFitxa stElem;
int iKont;
long liZenbatBit;
f = fopen(sFitxIzen, "rb");
fseek(f, 0L, SEEK_END); // fitxategiaren bukaeran kokatu
liZenbatBit = ftell(f); // fitxategiaren tamaina eskuratu
fseek(f, 0L, SEEK_SET); // fitxategiaren hasieran kokatu
// elementu guztiak prozesatu...
for (iKont = 1; iKont <= liZenbatBit/sizeof(struct tstFitxa); iKont++)
{
fread(&stElem, sizeof(struct tstFitxa), 1, f); // elementu bat irakurri eta...
printf("(1) %d. ikaslearen datuak: | %-20s | %d | %.2f |\n",
iKont, stElem.sIzenDeiturak, stElem.iDeialdia, stElem.fNota);
fseek(f, (-1)*(long)sizeof(struct tstFitxa), SEEK_CUR); // fitxategian posizio bat atzera
fread(&stElem, sizeof(struct tstFitxa), 1, f); // elementu bat irakurri eta...
printf("(2) %d. ikaslearen datuak: | %-20s | %d | %.2f |\n",
iKont, stElem.sIzenDeiturak, stElem.iDeialdia, stElem.fNota);
}
fclose(f);
}
// fitxategi osoa prozesatzeko funtzioa
void DatuGuztiakAldatu(const char sFitxIzen[])
{
FILE *f;
FILE *fLAG;
struct tstFitxa stElem;
int iKont;
long liZenbatBit;
f = fopen(sFitxIzen, "r+b");
fLAG = fopen(sLAGUNTZAILEA, "w+b");
fseek(f, 0L, SEEK_END); // fitxategiaren bukaeran kokatu
liZenbatBit = ftell(f); // fitxategiaren tamaina kalkulatu
fseek(f, 0L, SEEK_SET); // fitxategiaren hasieran kokatu
fseek(fLAG, 0L, SEEK_SET); // fitxategi laguntzailearen hasieran kokatu
// elementu guztiak prozesatu laguntzailea elikatuz...
for (iKont = 1; iKont <= liZenbatBit/sizeof(struct tstFitxa); iKont++)
{
fread(&stElem, sizeof(struct tstFitxa), 1, f); // elementu bat irakurri
stElem.iDeialdia++; // deialdia inkrementatu
fwrite(&stElem, sizeof(struct tstFitxa), 1, fLAG); // fitxategi laguntzailean idatzi
printf("Laguntzailean idatzi dira %d. ikaslearen datuak: | %-20s | %d | %.2f |\n",
iKont, stElem.sIzenDeiturak, stElem.iDeialdia, stElem.fNota);
}
fseek(f, 0L, SEEK_SET); // fitxategiaren hasieran kokatu
fseek(fLAG, 0L, SEEK_SET); // fitxategi laguntzailearen hasieran kokatu
// helburuko fitxategiaren elementu guztiak zapaldu...
for (iKont = 1; iKont <= liZenbatBit/sizeof(struct tstFitxa); iKont++)
{
fread(&stElem, sizeof(struct tstFitxa), 1, fLAG); // laguntzailetik elementu bat irakurri
fwrite(&stElem, sizeof(struct tstFitxa), 1, f); // fitxategian idatzi
}
fclose(f);
fclose(fLAG);
}
