Capitolul 13

Intrari/iesiri si fisiere

In acest capitol vom explica folosirea unor functii de intrare/iesire (printre care si "printf()" si "scanf()"). De asemenea vom arata modurile de deschidere a fisierelor (pentru procesarea lor) si cum se foloseste un pointer catre fisier.

13.1 Functia de iesire "printf()"

Are doua proprietati importante care permit o folosire flexibila la un nivel inalt:
- poate fi tiparita o lista de argumente de lungime arbitrara;
- afisarea este controlata de specificari de conversie simple (sau formate).
Functia "printf()" primeste sirul de caractere din fisierul standard de iesire (stdout), care este normal conectat la ecran. Lista de argumente a lui "printf()" are doua parti:
sirul_de_control si celelalte_argumente

Exemplu: In cazul apelului:

printf("Produsul %d %s $%f\n", 2, "costa", 3.77);
avem
sirul_de_control: "Produsul %d %s $%f\n"
celelalte_argumente: 2, "costa", 3.77
Expresiile din 'celelalte_argumente' sunt evaluate si convertite conform cu formatele din sirul de control si apoi plasate in sirul de iesire. Caracterele din sirul de control care nu fac parte dintr-un format sunt plasate direct in sirul de iesire. Simbolul % introduce o
specificare de conversie sau format. O specificare de conversie este un sir care incepe cu % si se termina cu un caracter de conversie.
Tabelul de mai jos reprezinta caracterele de conversie (si modul lor de afisare) pentru functia "printf()":

Exemplu: Iata un exemplu de folosire a formatului "%n":

#include
void main()
{
int * pi;
printf("Mai multe caractere %n.\n", pi);
printf("Nr.caractere = %d", *pi);
}
Pe ecran se va afisa numarul de caractere afisate pana la aparitia formatului "%n" (in cadrul instructiunii de afisare "printf()" curente), adica 20. Functia "printf()" intoarce un "int" ce reprezinta numarul de caractere tiparite dupa inlocuirea corespunzatoare a specificatorilor de conversie.

Exemplu:

#include
void main()
{
int * pi;
int a = printf("Mai mult de %d caractere %n.\n", 10, pi);
printf("Numarul de caractere intors de functia printf() este %d\n", a);
printf("Nr.caractere = %d", *pi);
}
In specificarile de conversie pot fi incluse informatii de formatare explicite. Daca ele nu apar, atunci sunt folosite cele implicite. De exemplu, formatul %f cu argumentul 3.77 va afisa 3.770000. Numarul este afisat pe 6 caractere la dreapta punctului zecimal (implicit). Intre % (care specifica inceputul unei specificari de conversie) si caracterul de conversie de la sfarsit, pot apare in ordine:
- zero sau mai multe caractere (flag) care modifica intelesul specificarii de conversie;
- un intreg pozitiv optional care specifica minimul lungimii campului a argumentului convertit. Locul unde un argument este tiparit se numeste "campul sau", iar numarul de spatii folosit pentru afisarea sa se numeste "lungimea campului". Daca argumentul convertit are mai putine caractere decat lungimea campului specificat, atunci acesta se va completa cu spatii (la stanga sau dreapta). Daca argumentul convertit are mai multe caractere decat lungimea campului specificat, atunci lungimea campului se va mari cu cat este necesar. Daca intregul care defineste lungimea campului incepe cu zero si argumentul ce se tipareste este ajustat dreapta in campul sau, atunci pentru umplerea sa se vor folosi zerouri in loc de spatii;
- o "precizie" optionala, care este specificata de un punct urmat de un intreg nenegativ. Pentru conversii d, i, o, u, x si X aceasta specifica numarul minim de cifre ce trebuie afisate. Pentru conversii e, E si f aceasta specifica numarul de cifre de la dreapta punctului zecimal. Pentru conversii g si G aceasta specifica numarul maxim de cifre semnificative. Pentru conversie cu s, aceasta specifica numarul maxim de caractere ce trebuie tiparite dintr-un sir;
- un h sau l optional, care este un modificator "short" sau "long", respectiv. Daca h este urmat de un d, i, o, u, x sau X, atunci aceasta este o specificare de conversie relativ la "short int" sau "unsigned short int". Daca un h este urmat de n, atunci argumentul corespunzator este un pointer catre "short int" sau "unsigned short int". Daca l este urmat de d, i, o, u, x sau X, atunci specificarea de conversie se aplica unui argument "long int" sau "unsigned long int". Daca l este urmat de caracterul n, atunci argumentul corespunzator este un pointer catre "long int" sau "unsigned long int";
- L optional, care este un modificator "lung". Daca L este urmat de e, E, f, g sau G, specificarea de conversie se aplica unui argument "long double".

Caracterele "flag" sunt:
- semnul "-" va implica alinierea spre stanga a argumentului convertit in campul sau. Daca nu gasim nici un semn "-", atunci alinierea argumentului convertit se face la dreapta campului.
- semnul "+" va implica afisarea semnului "+" in cazul numerelor pozitive (functioneaza pentru d, i, e, E, f, g si G). Toate numerele negative incep cu semnul minus.
- un spatiu, care semnifica ca un numar pozitiv (ce provine dintr-o conversie unsigned) are la inceput un spatiu;
- un "#", care semnifica ca rezultatul trebuie convertit la o forma alternativa ce depinde de caracterul de conversie. Daca caracterul de conversie este "o", atunci "#" cauzeaza afisarea unui zero in fata numarului octal. Intr-o conversie x sau X, "#" cauzeaza 0x, respectiv 0X, in fata numarului hexazecimal. In conversiile g si G, acesta cauzeaza tiparirea unor zerouri la coada (pana la un anumit numar de zecimale, de obicei 5). In conversiile e, E, f, g sau G, aceasta cauzeaza tiparirea punctului zecimal, chiar si cu precizia 0. Pentru alte conversii, comportarea lui "#" este nedefinita.
- un "0" (zero), care inseamna ca in loc de spatii sunt folosite zerouri. Cu caracterele de conversie d, i, o, u, x, X, e, E, f, g si G, aceasta poate produce zerouri nesemnificative (in fata numarului).

Intr-un format, lungimea campului sau precizia (sau ambele), pot fi specificate folosind *, in loc de un intreg, lucru care indica ca o valoare se obtine dintr-o lista de argumente.

Exemplu:

int m, n;
double x = 333.7777777;
. . . . . . . . . . .
/* citeste m si n (sau le calculam cumva) */
. . . . . . . . . . .
printf("x = %*.*f\n", m, n, x);

Daca argumentul corespunzator lungimii campului are lungime negativa, atunci se considera "-" ca fiind un "flag" urmat de o valoare pozitiva. Daca argumentul corespunzator preciziei are valoare negativa, atunci acesta se considera ca lipseste.
Tabelul de mai jos contine formate de caractere si siruri (folosim ghilimele pentru delimitarea vizuala a campului, ele nefiind afisate).

Declaratii si initializari

char c = 'A', s[] = "Luna rosie!";

13.2 Functia de intrare "scanf()"

Are doua proprietati importante care permit o folosire flexibila la un nivel inalt:
- poate citi o lista de argumente de lungime arbitrara;
- intrarea este controlata de specificari de conversie simple (sau formate).
Functia "scanf()" citeste caractere din fisierul standard "stdin". Lista de argumente a functiei "scanf()" are doua parti:
sir_de_control si celelalte_argumente

Exemplu: Fie declaratiile si apelul functiei "scanf()":

char a, b, c, s[100];
int n;
double x;
scanf("%c%c%c%d%s%lf", &a, &b, &c, &n, s, &x);
Avem:
sir_de_control: "%c%c%c%d%s%lf"
celelalte_argumente: &a, &b, &c, &n, s, &x
Celelalte argumente urmate de un sir de control consta dintr-o lista separata prin virgule de expresii pointer sau adrese (reamintim ca "s" este insusi o adresa).

Directive in sirul de control

Sirul de control din "scanf()" este compus din trei tipuri de "directive":
- caractere ordinare
- spatii goale
- specificari de conversie

Caractere ordinare

Caracterele din sirul de control (diferite de spatiile goale si caracterele din specificarile de conversie) sunt numite "caractere ordinare". Caracterele ordinare trebuie sa se regaseasca (potriveasca) cu cele din sirul de la intrare.

Exemplu:

float suma;
scanf("$%f", &suma);

Caracterul $ este ordinar. Deci trebuie sa intalnim $ in sirul de la intrare. Daca are loc o potrivire cu succes, atunci spatiile goale (daca exista) se vor sari, si caracterele care urmeaza se vor potrivi la o valoare (in virgula mobila). Valoarea convertita va fi plasata in memorie la adresa variabilei "suma".

Caractere "spatii goale"

Caracterele spatii goale din sirul de control care nu fac parte dintr-o specificare de conversie se potrivesc cu orice spatiu liber din sirul de intrare.

Exemplu:

char c1, c2, c3;
scanf(" %c %c %c", &c1, &&c2, &c3);
Daca sirul de la intrare contine literele "a", "b", si "c", atunci "c1", "c2" si "c3" vor avea valorile "a", "b", "c" (a nu se citi ghilimelele). O directiva spatiu liber implica ca spatiile goale (daca exista) sa fie ignorate din sirul de intrare.

Exemplu: Urmatoarele instructiuni sunt echivalente:

scanf(" %c %c %c", &c1, &c2, &c3);
scanf("\t%c \t %c\n%c", &c1, &c2, &c3);

Intre % si caracterul de conversie poate fi:
- caracterul * optional, care indica o suprascriere, urmata de un intreg optional care defineste lungimea maxima a sirului de intrare (care va fi deci ignorat), urmat optional de h, l, L care modifica caracterul de conversie;
- modificatorul h, care poate precede caracterele de conversie d, i, o, u, x sau X. Acesta precizeaza ca valoarea convertita trebuie memorata ca un "short int" sau "unsigned short int";
- modificatorul l, care poate precede caracterele de conversie d, i, o, u, x, X sau e, E, f, g, G. In primul caz, acesta precizeaza ca valoarea trebuie memorata ca un "long int" sau "unsigned long int".
In cel de-al doilea caz, acesta precizeaza ca valoarea convertita trebuie memorata ca un "double";
- modificatorul L, care poate precede caracterele de conversie e, E, f,g sau G. Acesta precizeaza ca valoarea convertita trebuie memorata ca un "long double".
Caracterele din sirul de intrare sunt convertite la valori in concordanta cu specificarile de conversie din sirul de control si plasate la adresa data prin expresia pointer corespunzatoare din lista de argumente. Cu exceptia unei intrari caracter, un camp de scanare consta dintr-un numar contiguu de caractere diferite de spatiu (conforme cu conversia specificata). Campul de scanare se termina cand se gaseste un caracter neadecvat, sau s-a depasit lungimea scanarii (daca ea este precizata), sau s-a ajuns la EOF (depinde care vine primul).
Specificarea %s sare spatiile goale si apoi citeste caractere diferite de spatiu pana cand se gaseste spatiu sau EOF (depinde care vine primul). In schimb, specificarea %5s sare spatiile goale, apoi citeste caracterele diferite de spatiu, dar cel mult 5 caractere sau pana la EOF (depinde care vine primul). Cand se citeste un sir de caractere, se presupune ca in memorie este deja rezervat suficient spatiu pentru memorarea sa (cu tot cu santinela \0).
Formatul %nc (unde "n" este o constanta intreaga) foloseste la citirea urmatoarelor n caractere, inclusiv spatii goale (se presupune ca s-a rezervat suficient spatiu in memorie pentru pastrarea lor, iar caracterul \0 nu se mai adauga).

Numere in virgula mobila din sirul de intrare

Numerele in virgula mobila din sirul de intrare sunt formatate cu un semn optional (+ sau -) urmat de un sir de cifre cu un punct zecimal optional, urmat de parte exponentiala optionala. Partea exponentiala consta din e sau E, urmate de un semn optional (+ sau -), urmat de un sir de cifre.

Exemple:

77
+7.7e1
770.0E-1
+0.003

Nu uitati: Sirul de intrare nu este cod C (se aplica reguli diferite).


Folosirea multimii de scanare

O specificare de conversie de forma %[sir] indica ca un sir special poate fi citit. Multimea de caractere dintre parantezele patrate se numeste "multime de scanare". Daca primul caracter din multimea de scanare nu este caracterul circumflex "^", atunci sirul trebuie sa fie construit numai din caractere ce apartin multimii de scanare.

Exemple:

1. Formatul %[abc] va citi orice sir care contine literele "a", "b" si "c" si se va opri daca orice alt caracter va apare in sirul de intraare, inclusiv un spatiu (ex. scanf("%[abc]", m)).
2. In contrast, formatul %[^abc] va citi orice ce se va termina cu "a", "b" sau "c", dar nu si spatiu.
3. Fie codul
char m[30];
scanf("%29[AB \t\n]", m);
Aceasta va produce citirea in vectorul de caractere "m" a unui sir de cel mult 29 caractere. Sirul consta din literele A, B,
spatiu, tab, newline. La sfarsit, se va scrie \0.
4. Programatorii de obicei gandesc o linie ca un sir de caractere, inclusiv spatii si taburi, care se termina cu un newline.
Un mod (elegant) de a citi o linie in memorie este folosirea unei multimi de scanare potrivita:
char linie[256];
while (scanf(" %[^\n]", linie) == 1)
printf("%s\n", linie);

Valoarea returnata de "scanf()"

Cand "scanf()" este apelata, poate apare o greseala la citire. De exemplu, daca nu sunt caractere in sirul de intrare, atunci "scanf()" va intoarce -1 (EOF). Daca apare o nepotrivire intre formatele din "scanf()" si sirul de la intrare, atunci "scanf()" va intoarce numarul de conversii cu succes pana in acel moment. Numarul este zero daca nu apar conversii. Daca "scanf()" reuseste cu succes, atunci este returnat numarul de conversii cu succes. La fel, acest numar poate fi zero.

Exemplu:

char c, *sir_control, s[7], m[18];
int a, contor;
sir_control = "%d , %*s %% %c %[abc] %*s %5s %s";
contor = scanf(sir_control, &a, &c, s, m, &m[5]);
Consideram ca avem la intrare sirul:
23 , ignora % C abacus citeste_aceasta**
Atunci:
"23" este plasat in memorie la adresa lui "a"
"," se potriveste
"ignora" este un sir ignorat
"%" se potriveste
"C" este plasat in memorie la adresa lui "c"
"abac" este plasat in s[0],...,s[4]='\0'
"us" este un sir ignorat
"cites" este plasat in m[0],...,m[5]='\0'
"te_aceasta**" este plasat in m[5],...,m[18]='\0'
Din moment ce au avut loc 5 conversii cu succes, rezulta ca functia "scanf()" va intoarce valoarea 5.

Exemplu: Tabelul de mai jos contine mai multe exemple de directive de control pentru functia "scanf()":

13.3 Functiile "sprintf()" si "sscanf()"

Functiile "sprintf()" si "sscanf()" sunt versiuni ce folosesc siruri ale functiei "printf()" si "scanf()", respectiv. Prototipurile lor,
care se gasesc in "stdio.h", sunt:
int sprintf(char *s, const char *format, ...);
int sscanf(const char *s, const char *format, ...);
Punctele ... indica compilatorului faptul ca functia poate avea un numar variabil de argumente. O instructiune de forma:
sprintf(sir, sir_de_control, alte_argumente);
scrie rezultatul in sirul de caractere "sir". Intr-o maniera similara, o instructiune de forma:
sscanf(sir, sir_de_control, alte_argumente);
citeste rezultatul din sirul de caractere "sir".

Exemplu:

char * sir_intrare = "1 2 3 ab";
char sir_iesire[100], temp[100];
int a, b, c;
sscanf(sir_intrare, "%d%d%d%s", &a, &b, &c, &temp);
sprintf(sir_iesire, "%s %s %d%d%d\n", temp, temp, a, b, c);
printf("%s", sir_iesire);
Atunci se va afisa la ecran:
ab ab 123
Atentie ! Este responsabilitatea programatorului sa rezerve spatiu suficient pentru memorarea lui "sir_iesire" din "sprintf()".

13.4 Functiile "fprintf()" si "fscanf()"

Functiile "fprintf()" si "fscanf()" sunt versiunile pentru fisiere a functiilor "printf()" si "scanf()". Fisierul "stdio.h" contine un numar de constructii referitoare la fisiere. In acest fisier exista si tipul structura FILE a caror membrii descriu starea curenta a unui fisier. Tot in acest fisier, sunt definiti trei pointeri la fisier. Este vorba despre "stdin", "stdout" si "stderr".

In fisierul "stdio.h" exista prototipurile pentru functiile "fprintf()" si "fscanf()":
int fprintf(FILE *ofp, const char *format, ...);
int fscanf(FILE *ifp, const char *format, ...);
("ofp" - outfile pointer, iar "ifp" - infile pointer)
Punctele ... spun compilatorului ca functia ia un numar variabil de argumente. O instructiune de forma:
fprintf(pointer_catre_fisier, sir_de_control, alte_argumente);
va scrie in fisierul spre care pointeaza "pointer_catre_fisier". In particular,
fprintf(stdout, ...); este echivalent cu printf(...);
Intr-o maniera similara, o instructiune de forma:
fscanf(pointer_catre_fisier, sir_de_control, alte_argumente);
va citi din fisierul spre care pointeaza "pointer_catre_fisier". In particular,
fscanf(stdin, ...); este echivalent cu scanf(...);

13.5 Accesarea fisierelor

Fisierele au cateva proprietati importante:
- au un nume
- trebuie inchise si deschise
- poate fi scris in ele sau citit din ele sau adaugat la ele
- cand sunt deschise avem acces la ele de la inceput la sfarsitul lor
Abstract, un fisier poate fi gandit ca un sir de caractere. Dupa ce un fisier a fost deschis, sirul poate fi accesat folosind functii din biblioteca standard.

Exemplu:

#include
void main()
{
int suma = 0, val;
FILE *ifp, *ofp;
ifp = fopen("fis_in", "r"); /* deschis pentru citire */
ofp = fopen("fis_out", "w"); /* deschis pentru scriere */
. . . . . .
}
In acest exemplu, am deschis fisierul "fis_in" pentru citire si "fis_out" pentru scriere. Din momentul deschiderii fisierului, pointerul catre fisier poate fi folosit exclusiv pentru referirea la intregul fisier. Daca, de exemplu, presupunem ca fisierul "fis_in" are numere intregi, atunci iata o modalitate de a face suma lor:
while (fscanf(ifp, "%d", &val) == 1)
sum += val;
fprintf(ofp, "Suma lor este %d.\n", suma);
Ca si "scanf()", functia "fscanf()" intoarce numarul de conversii cu succes. Dupa ce terminam de exploatat fisierele, putem sa le inchidem:
fclose(ifp);
fclose(ofp);
Un apel de functie de forma "fopen(nume_fisier, mod)" deschide fisierul respectiv intr-un mod particular si returneaza un pointer catre fisier. Sunt mai multe posibilitati pentru modul de accesare a fisierului:

Fiecare dintre aceste moduri se poate termina cu "a+". Asta inseamna ca fisierul poate fi deschis si pentru citire si pentru scriere.

Deschiderea pentru citire a unui fisier care nu exista, sau care nu poate fi citit, va esua si functia "fopen()" va intoarce pointerul NULL. Deschiderea unui fisier pentru scriere va avea ca efect crearea unui fisier (daca acesta nu exista) sau se va suprascrie peste unul existent. Deschiderea unui fisier pentru adaugare va avea ca efect crearea unui fisier (daca acesta nu exista) sau se va scrie la sfarsitul sau (daca acesta exista).
Daca scriem modul "r+" sau "w+" atunci fisierul se considera ca a fost deschis pentru citire si scriere. Cu toate acestea citirile nu pot fi urmate de scrieri decat daca s-a ajuns la EOF sau au intervenit apeluri ale functiilor "fseek()", "fsetpos()" sau "rewind()". De asemeni, scrierile nu pot fi urmate de citiri decat daca s-a ajuns la EOF sau au intervenit apeluri ale functiilor "fflush()", "fseek()", "fsetpos()" sau "rewind()".

13.6 Accesarea aleatoare a unui fisier

In plus fata de accesarea unui caracter unul dupa altul intr-un fisier (acces secvential), noi putem accesa caractere in locuri diferite (acces aleator). In biblioteca C, functiile "fseek()" si "ftell()" sunt folosite pentru accesarea aleatoare a unui fisier. O expresie de forma:
ftell(pointer_catre_fisier)
returneaza valoarea curenta a indicatorului de pozitie in fisier. Valoarea reprezinta numarul de octeti pornind de la inceputul fisierului, numarand de la 0. Cand un caracter este citit dintr-un fisier, sistemul incrementeaza indicatorul de pozitie cu 1. Tehnic vorbind, indicatorul de pozitie in fisier este un membru a structurii catre care pointeaza "pointer_catre_fisier". Pointerul catre fisier nu pointeaza catre caractere individuale din fisier (aceasta este o eroare de conceptie pe care o fac programatorii incepatori).
Functia "fseek()" are trei argumente:
- pointer catre fisier
- offset (intreg)
- un intreg care arata locul fata de care se calculeaza offset-ul
O instructiune de forma
fseek(pointer_catre_fisier, offset, mod);
seteaza indicatorul de pozitie la o valoare care reprezinta "offset" octeti pornind de la "mod". Valoarea lui "mod" poate fi 0, 1 sau 2, insemnand ca ne referim la inceputul fisierului, pozitia curenta sau sfarsitul fisierului, respectiv.
Atentie ! Functiile "fseek()" si "ftell()" sunt garantate sa lucreze numai pentru fisiere binare. In MS-DOS, daca dorim sa lucram cu aceste functii, trebuie sa deschidem acest fisier in acces binar. In UNIX, din moment ce exista doar un singur mecanism de lucru cu fisierele, orice mod de deschidere pentru fisier este bun.

13.7 Stil de programare

Un stil bun de programare va verifica daca functia "fopen()" lucreaza asa cum ne asteptam (in orice program serios, acest lucru trebuie facut). Iata cum ar trebui sa se faca deschiderea fisierului "fis1" in acces de citire:
if ((ifp = fopen("fis1", "r")) == NULL)
{
printf("\nNu putem deschide fisierul fis1. Pa!\n\n");
exit(1);
}