CURS 8

Managementul fişierelor în C Fisier - colecţie de date, păstrată pe un dispozitiv periferic (magnetic sau optic)

- succesiune de caractere, de cuvinte, linii sau pagini ale unui document de tip text - înregistrări ale unei baze de date - pixelii unei imagini grafice - etc.

Operatii - deschidere, închidere, creare, citirea datelor, adăugarea de înregistrări, poziţionarea pe o

anumită înregistrare, ştergerea fişierelor

1. Pentru prevenirea folosirii necorespunzătoare a unui fişier, sistemul de operare instalat pe calculator trebuie să fie înştiinţat despre scopul în care este deschis fişierul şi despre operaţiile care vor fi efectuate (citire, scriere, adăugare) asupra datelor.

2. La încheierea operaţiunilor care se efectuează asupra datelor dintr-un fişier acesta trebuie închis deoarece în caz contrar, sistemul de operare nu poate actualiza datele referitoare la acel fişier (dimensiune, data ultimei accesări, etc.).

Accesare - de la începutul sau de la sfârşitul fişierului - dintr-un loc oarecare din fişier.

1. fişiere text stochează datele ca o secvenţă de caractere alfanumerice conţinutul acestor fişiere este lizibil şi poate fi editat direct cu ajutorul unui editor de texte. sunt organizate pe rânduri, fiecare rând fiind delimitat de caracterul de sfârşit de rând (EOL) sunt citite caracter cu caracter

=> funcţiile pentru citirea şi scrierea lor vor fi aproape identice cu cele folosite pentru citirea de la tastatură şi respectiv scrierea pe monitor.

sunt procesate secvenţial => un fişier text se deschide de obicei numai pentru un anumit tip de operaţie la un

moment dat (citire, scriere sau adăugare)

Tipuri de fişiere

2. fişiere binare pot să conţină orice tip de date, codate într-o formă binară, în secvenţe de bytes pot conţine orice fel de informaţie: text formatat, imagini, sunete, etc. diferă de fişierele text în două puncte esenţiale:

fiecare octet de date este transferat pe sau de pe disc neprocesat interpretarea lor este lăsată pe seama programatorului (pot fi citite sau scrise în orice

mod dorit de către programator) pot fi procesate secvenţial sau aleator sunt accesate mai rapid decât fişierele text sunt înţelese numai de programe scrise special să lucreze cu astfel de fişere (de ex. bazele de

date)

Exemple

Declararea fişierelor

FILE *df;

FILE - cuvânt cheie care semnifică o structură de date de tip fişier

df - descriptor de fişier - pointer spre tipul FILE.

Exemple FILE *f1, *fin, *frez, *ftext;

Funcţia fopen: -> #include <fstream> (in C++) FILE *fopen(const char *cale, const char *mod); cale - pointer spre un şir de caractere care defineşte calea spre fişierul care se deschide mod - pointer spre un şir de caractere care defineşte modul de prelucrare a fişierului după deschiderea acestuia.

Deschiderea fişierelor

cale = reprezintă orice nume valid de fişier, eventual precedat de calea de directoare până la acesta, cuprins între ghilimele. Dacă trebuie specificată calea până la respectivul fişier, atunci directoarele căii vor fi separate prin \\ ca de exemplu: "d:\\input.txt".

fopen - returneaza: in caz de succes - un pointer la fisier in caz de eroare – pointerul NULL

mod = atributul fişierului - poate avea valorile "r" - fişierul se deschide pentru citire "w" - fişierul se deschide pentru scriere "a" - fişierul se deschide pentru adăugare de înregistrări - nu permite repozitionarea in fisier "rb" - fişierul se deschide pentru citire binară "wb" - fişierul se deschide pentru scriere binară "r+b" - caz în care fişierul se deschide pentru citire şi scriere binară

1. Un fişier inexistent, deschis în modul "w" va fi creat (dacă este posibil) în momentul deschiderii, iar un fişier existent deschis în modul "w" va fi creat din nou, ceea ce înseamnă că vechiul său conţinut se va şterge. 2. Deschiderea în modul "w" va eşua dacă sistemul nu poate deschide fişierul -disc plin, disc protejat la scriere, nu exista drepturi de acces la fisier 3. Deschiderea în modul "r" eşuează daca: fişierul nu există, fişierul este protejat într-un anume fel 4. Unui fişier inexistent deschis în modul "r" i se va asocia pointerul NULL. 5. La deschiderea în modul "a", dacă fişierul există, poziţionarea se face la sfârşitul fişierului, iar dacă nu există atunci el va fi creat. 6. Deschiderea în modul "a" poate eşua în aceleaşi cazuri în care eşuează deschiderea în modul "w".

Exemple FILE *f, *fin; f=fopen("notean1.dat","r"); /* se deschide fisierul notean1.dat, din directorul curent, in modul citire.*/

fin=fopen("c:\\soft\\config.ini","w"); // se deschide fisierul c:\soft\config.ini in modul scriere.

Pointerul NULL poate fi folosit pentru testarea posibilităţii deschiderii unui fişier if((f=fopen("fis_test","r"))==NULL) printf("Eroare la deschiderea fisierului!");

sau : f=fopen("fis_test","r"); if(!f) printf("Eroare la deschiderea fisierului!");

Închiderea fişierelor

int fclose(FILE *pf);

pf - pointerul spre tipul FILE - valoarea lui a fost determinată de către funcţia fopen la deschiderea fişierului.

- returnează valoarea 0 la închidere reuşită şi valoarea -1 în caz de eroare.

Exemplu 1. fclose(fin);

2. // Testarea închiderii reusite a unui fisier // se poate intampla atunci cand pointerul fin nu a fost initializat if(fclose(fin)) //sau: if(fclose(fin)!=0) { printf("Fisierul nu exista ! "); exit(0); }

Citirea şi scrierea fişierelor fscanf, fprintf, fgetc, fputc, fgets, fptus, fread, fwrite.

fscanf(*pf, "control", &par1, &par2, ... , &parn); fprintf(*pf,"control",par1, par2, ... , parn);

Exemple FILE *fin, *fout; fin=fopen("test.inp","r"); fout=fopen("test.out","w"); ... fscanf(fin,"%d",&n); fprintf(fout,"n^2= %d",n*n);

...

După fiecare caracter citit, poziţia în fişier avansează cu o unitate.

- folosite pentru citirea/scrierea fişierelor binare.

Funcţiile fread şi fwrite

Funcţia fwrite

- scrie un bloc de memorie în fişierul specificat Functia fread

- citeşte date dintr-un fişier binar şi le pune într-un bloc de memorie.

Apelul funcţiei fwrite :

fwrite( ptr, size, n, f )

ptr - pointerul la blocul de date care va fi scris în fişierul binar size - lungimea în octeţi a blocului scris n - numărul de itemi scrisi f - pointer la fişierul in care se scrie Numărul de octeţi scrişi este n*size. Apelul funcţiei fread:

fread( ptr, size, n, f )

ptr - pointer la blocul de memorie în care se vor prelua datele citite din fişier size - lungimea în octeţi a blocului citit n - numărul de itemi citiţi f - pointer la fişierul din care se face citirea

Funcţiile fgetc şi fputc -folosite pentru citirea, respectiv scrierea unui caracter dintr-un/într-un fişier (stream) - returnează caracterul citit sau scris în caz de succes şi EOF în caz de eroare.

EOF - caracter constant care indică sfârşitul de fişier. - citirea lui se testeaza cu funcţia feof feof returnează: - o valoare nenulă dacă a fost detectat caracterul EOF - zero dacă nu a fost citit caracterul EOF.

Funcţiile fgets şi fputs

- folosite pentru preluarea într-un şir, respectiv scrierea într-un şir a unor caractere dintr-un/într-

un fişier (stream).

Prototipuri: fgetc(FILE *stream);

fputc(int c, FILE *stream);

Prototipuri: char *fgets(char *s, int n, FILE *stream); int fputs(const char *s, FILE *stream);

Funcţia fgets - preia într-un şir n-1 caractere dintr-un fişier - returnează şirul la care pointează s, respectiv pointerul NULL în caz de

eroarea sau la întâlnirea caracterului EOF.

Funcţia fputs - scrie un şir de caractere într-un fişier - returnează ultimul caracter scris, respectiv EOF în caz de eroare.

Exemple //Citirea unui rand dintr-un fisier char sir[100]; FILE *f; f=fopen("d:\\test.inp","r"); fgets(sir,100,f); printf("Sirul citit este: %s",sir); fclose(f);

// Tiparirea la imprimanta (functioneaza pentru o imprimanta // conectata la portul LPT1 FILE = *prt; if((prt=fopen("LPT1","w"))==NULL) { printf("\a\nPrinter nedisponibil"); exit(0); } else fprintf(prt,"Test tiparire la imprimanta!");

Funcţiile ftell şi fseek ftell - determină poziţia curentă a capului de citire/scriere

- are prototipul: long ftell(FILE *pf)

- returnează o valoare care reprezintă deplasamentul în octeţi al poziţiei capului de citire/scriere faţă de începutul fişierului. fseek - permite poziţionarea aleatoare într-un fişier

- returnează 0 în caz de succes (poziţionare corectă a cursorului în fişier) - prototipul funcţiei: int fseek(FILE *pf, long deplasament, int origine);

pf - pointer spre tipul FILE

- defineşte fişierul în care se face poziţionarea capului de citire/scriere - valoarea sa este determinată la deschiderea fişierului.

Deplasament - defineşte numărul de octeţi peste care se va deplasa capul de citire/scriere al discului - poate fi o valoare întreagă pozitivă sau negativă.

Origine - determină locul din care se face deplasarea capului - poate avea valorile: 0 -> deplasare de la inceputul fisierului 1 -> deplasare de la pozitia curenta a capului de citire/scriere a fisierului 2 -> (deplasare de la sfârşitul fişierului)

Poziţionarea într-un fişier

Ştergerea unui fişier - se foloseşte funcţia unlink - prototip: int unlink(const char *cale);

cale - specifică fişierul care va fi şters. Funcţia nu poate şterge fişierele read-only sau fişierele deschise şi returnează valoarea 0 la ştergere reuşită, respectiv -1 în caz de eroare.

Program exemplu: crearea unui fişier text cu 5 linii #include <stdio.h> #include<string.h>

#include <fstream>

int main( ) { FILE *fp; char text[25]; int i; fp = fopen("d:\\flinii.txt","w"); strcpy(text,"Acesta este randul: "); for (i=1;i<=5;i++) fprintf(fp,"%s%d\n",text,i); fclose(fp);

return 0; }

Program exemplu: determinarea numărului de caractere dintr-un fişier (se numără şi caracterele de rând nou) #include <stdio.h> #include <stdlib.h>

#include <fstream>

int main( ) { FILE *fp; char c; int n=0; /*Se deschide fisierul de intrare, testandu-se deschiderea corecta a acestuia. Daca deschiderea fisierului nu se poate realiza (fisier inexistent) functia fopen returneaza pointerul NULL*/ if((fp = fopen("d:\\flinii.txt","r"))==NULL) { printf("Eroare la deschiderea fisierului!"); exit(1); } while(fscanf(fp,"%c",&c)==1) { n++; } fclose(fp); printf("In fisier sunt %d caractere.",n); return 0; }

Exerciţiu Modificaţi programul de mai sus astfel încât caracterele de rând nou să nu fie numărate.

Program exemplu: interogarea utilizatorului în cazul suprascrierii unui fişier deschis în modul "w".

#include<stdio.h>

#include<conio.h>

int main()

{

FILE *fout;

char nfout[20];

char opt;

int OK;

do {

printf("\nIntroduceti numele fisierului de iesire: " );

gets(nfout) ;

fout=fopen(nfout,"r") ;

if(fout!=NULL) {

fclose(fout);

printf("\aFisierul exista! \nSuprascrieti acest

fisier? (D/N): ");

opt=getche();

switch(opt) {

case 'D':

{ OK=1;

fout=fopen(nfout,"w");

break;

}

default:

OK=0;

}

}

else

{ fclose(fout);

OK=1; fout=fopen(nfout,"w");

}

}

while((OK!=1)&&fout); if(opt=='D') fprintf(fout,"Suprascriere

in fisier!");

else fprintf(fout,"Scriere in

fisier!");

printf("\nTerminat!");

fclose(fout);

return 0;

}

Program exemplu: folosirea funcţiei fgets pentru tipărirea unui fişier pe ecran #include<stdio.h>

#include<conio.h>

int main()

{

char *c, rand[100],nf[25];

FILE *f;

printf("Introduceti numele fisierului: ");

scanf("%s",nf);

f=fopen(nf,"r");

do

{

c=fgets(rand,100,f); //functia fgets returneaza sirul la care pointeaza

//pointerul rand.

if(c)

printf("%s",rand);

}

while(c);

fclose(f);

while(!_kbhit());

return 0;

}

Program exemplu: folosirea funcţiilor fwrite şi fread //Testarea functiilor fwrite si fread #include <stdio.h> #include<stdlib.h> #include <string.h> struct bd { char n[20],p[20],tel[20]; int v; int s; }; void main() { FILE *fin; struct bd ag; char sir[20]; int *pi,*pu; if((fin=fopen("c:\\temp\\bd.dat","wb"))==NULL) { printf("Eroare la deschiderea fisierului!"); exit(1); }

strcpy(ag.n,"Popescu"); strcpy(ag.p,"Georgel"); strcpy(ag.tel,"0445111222"); ag.v=40; ag.s=1; fwrite(&ag,sizeof(ag),1,fin); fclose(fin); fin=fopen("c:\\temp\\bd.dat","rb"); fseek(fin,0,0); printf("Datele din fisier:\n\n"); fread(sir,sizeof(ag.n),1,fin); printf("NUME: \t\t%s\n",sir); fread(sir,sizeof(ag.p),1,fin); printf("PRENUME: \t%s\n",sir); fread(sir,sizeof(ag.tel),1,fin); printf("Telefon: \t%s\n",sir); fread(pi,sizeof(ag.v),1,fin); printf("Varsta: \t%d\n",*pi); fread(pu,sizeof(ag.s),1,fin); printf("Stare civila: \t%d\n",*pu); }

După rularea acestui program se obţine fişierul bd.dat în

directorul d:\c. Deschizând fişierul bd.dat cu un utilitar de gestiune a fişierelor, acesta va arăta sub forma:

Pe ecran, va fi tipărit:

Program exemplu: calculul coordonatelor centrului de masă al unui sistem de particule ale căror date se găsesc într-un fişier #include <stdio.h> #include <stdlib.h> #include <conio.h> FILE *fin,*fout; float m,x,y,z,sm,smx,smy,smz,xc,yc,zc; int i; char opt; void scrie_date() { fout=fopen("d:\\bc\\centru.rez","w"); fprintf(fout,"Nr. particule: %d",i); fprintf(fout,"\nsm= %g \nsmx= %g smy= %g smz= %g ",sm,smx,smy,smz); fprintf(fout,"\nxc= %g\t yc=%g\t zc=%g\n",xc,yc,zc); fclose(fout); } int main() { sm=smx=smy=smz=0; i=0; if((fin=fopen("d:\\bc\\centru.dat","r"))==NULL) { printf("\nFisierul nu poate fi deschis\a\a\a"); } while(!feof(fin)) { if(fscanf(fin,"%f%f%f%f",&m,&x,&y,&z)==4) { sm+=m; smx+=m*x; smy+=m*y; smz+=m*z; i++; } }

La laborator

xc=smx/sm; yc=smy/sm; zc=smz/sm; fclose(fin); if((fout=fopen("d:\\bc\\centru.rez","r"))!=NULL) { printf("\nAtentie! Fisierul de output exista!"); printf("\nCONTINUATI ? (Y/N)"); opt=getch(); fclose(fout); if((opt=='y')||(opt=='Y') ) scrie_date(); else { printf("\nExecutie terminata!"); exit(1); } } else scrie_date(); printf("\nTerminat!");

return 0; }

Bibliografie suplimentară http://www.codingunit.com/c-tutorial-binary-file-io

Programe cu parametri in linia de comandă

În C este posibilă apelarea programelor şi transferarea parametrilor acestora în linia de

comandă. Exemplu: suma 3.8 9.2

Funcţia main trebuie să fie definită sub următoarea formă: int main(int argc, char* argv[])

{ ... } argc - specifică numărul de argumente, adică numărul parametrilor din linia de comandă cu

care a fost apelat programul. - se determina in momentul lansarii aplicatiei argv[] - vector de pointeri la şiruri de caractere care constituie argumentele cu care este apelat

programul; fiecare element al vectorului de pointeri pointează la un şir (de fapt la primul caracter al şirului).

Lista de pointeri în argv este terminată întotdeauna cu pointerul NULL, astfel încât argv[argc] este NULL.

Prin convenţie, argv[0] este numele aplicaţiei (calea completă către programul executabil), iar cel

de-al doilea este primul argument furnizat de către utilizator. Dacă argc are valoarea 1 atunci nu există parametri în linia de comandă, după numele

programului.

Program exemplu: suma a două numere introduse în linia de comandă #include <stdio.h> #include <process.h> #include <math.h> main(int argc,char *argv[]) { double n1,n2,s; int n=argc; if(n<3) { printf("\nParametri insuficienti!"); exit(1); } else if(n>3) { printf("Prea multi parametri!"); exit(1); } else { n1=atof(argv[1]); //atof face conversia de la string la double n2=atof(argv[2]); s=n1+n2; printf("\nSuma numerelor introduse este %lf",s); } return 0;

}

Program exemplu: Tipărirea numelui programului şi a parametrilor săi din linia de comandă #include <stdio.h> int main(int argc, char *argv[]) { int i; printf("Numele programului este: %s\n",argv[0]); //Numele programului este primul pointer din tabloul de pointeri argv[] printf("Programul are %d parametri, si acestia sunt:\n",argc-1); //Numele programului nu este considerat explicit ca parametru for (i=1; i<argc; i++) printf("%s%s",argv[i],(i < argc- 1) ? " " : ""); //Se tipareste caracterul spatiu dupa fiecare parametru daca acel //parametru nu este ultimul return 0; }

Executabilul se lansează în execuţie într-o fereastră DOS (Start -> Run -> cmd) sub forma:

Tema Scrieti un program cu parametri in linia de comanda, pentru concatenarea a doua fisiere.