Tema: Analiza şi modelarea principiilor de prelucrare în baza fişierelor în limbajul C

Sistemul este un ansamblu integru organizat pe inter-legături şi cu acţiuni reciproce ale obiectelor, elementelor, componentelor unul cu altul,
care defineşte anumite funcţii. Funcţiile sistemului reprezintă nişte modalităţi de demonstrare ale activităţii şi stării de viaţă a sistemului şi ale
componentelor sale.
Abordarea sistemică trebuie să prevadă şi evidenţierea particularităţilor obiectelor sistemului aflat în studiu. Pe primul plan este problema
cunoaşterii caracterului şi mecanismului acestor legături şi al raporturilor dintre ele.
Esenţa abordării sistemice se exprimă prin următoarele supoziţii care sunt utile în stabilirea proprietăţilor obiectelor sau sistemelor studiate:
1. Integritatea sistemului faţă de mediul extern, adică unicitatea. Studierea sistemului într-un proces unic cu mediul înconjurător.
2. Decompoziţia întregului sistem pentru a obţine elementele esenţiale.
3. Elementele sistemului se găsesc în legături complexe şi interacţiune.
4. Ansamblul de elemente şi legături trebuie să reprezinte o structură şi o organizare a obiectelor bine definite, să exprime o ordonare şi o ierarhie
corespunzătoare.
5. Racordarea dintre legăturile elementelor sistemului prin metode speciale, gestiunea elementelor, determinarea scopului, controlul şi corectarea în baza
rezultatelor.
După A. Compte: „Interpretarea şi înţelegerea complexităţii sistemului depinde de cultura noastră, limbă, experienţa trecutului, pregătirea profesională şi
logică, pe care le folosim în conectarea părţilor, şaradelor sau elementelor unei mozaici sofisticate într-un moment unic.”
Note de curs
Tratarea informaţiilor cere prezenţa lor în memorie în timpul execuţiei programului dat. Dar în majoritatea
cazurilor trebuie neapărat ca aceste informaţii să fie conservate de o manieră durabilă .Ca exemplu elementar , se
poate de citat informaţiile relative ale clienţilor unor întreprinderi. De aceleaşi date (cod, client, numele clientului,
adresa ,cifra de afaceri ), sunt cele mai des exploatate pe o perioadă lungă de timp. Ele trebuie să fie rechemate la
moment şi în particular. În acest scop ele sunt scrise într-un fişier, care este stocat pe o memorie masivă (discul
magnetic) şi accesibil programului, manipulând informaţiile.
Un fişier nu este altceva decât o mulţime mai mult sau mai puţin importante de date, conservate pe un
oarecare suport. În ceea ce priveşte limbajul C , se poate de reprezentat un fişier ca un tablou gigantic permanent , în care un program poate să scrie
sau să citească datele . Un fişier trebuie să conţină elemente de aceeaşi natură , de un conţinut omogen . Contrar altor
limbaje, conţinutul unui fişier C nu este structurat la timp. Din contra aceste donaţii sunt simplu aranjate sub forma
unui şir de caractere(octeţi). Iată de ce un fişier este câteodată denumit flux de donaţii. Fiecare caracter (octet
conţinând caracterul ) luat individual poate fi localizat în fişier printr-un index. Mai mult ca atât ca un fişier să fie
considerat ca un şir nonstructurat de octeţi , îi încredinţează programatorului să creeze o structură de fişiere aşa
ca datele să fie administrate cum îl aud. Pentru aceasta dispune de o serie de funcţii adaptate , care îi permit să
manipuleze datele de toate dimensiunile şi toate tipurile.
În C se poate de lucrat pe două fişiere cu două niveluri :
 nivelul inferior
 nivelul superior
La nivelul inferior se folosesc metode de acces elementar , fondat pe funcţiuni, care se bazează pe rutinele
corespondente ale sistemului de exploatare , relative . Funcţiile nivelului inferior depind direct de sistemul de
exploatare, şi nu fac parte din standardul ANSI. Accesele la fişierele nivelului superior se fac într-o manieră puţin
mai elementară şi mai facilă Ele sunt fondate pe funcţii predefinite relativ complexe , independente de sistem de
exploatare, si implementate pe funcţii de nivel înalt.
Operaţiile neelementare. Deoarece un program trebuie să citească sau să scrie datele într-un fişier , printr-o
metodă de acces de un nivel mai înalt , informaţiile trec pentru a ajunge la destinaţia lor printr-un bufer . Acest
bufer este o zonă de memorie RAM în care sunt temporar stocate, înainte de a fi transferate la destinaţie ,
informaţii citite sau scrise în fişier . Avantajul este că nu este necesar de a declanşa o operaţie de intrare / ieşire
specific pentru fiecare informaţie citită sau scrisă . Din contra o singură operaţie în program permite de a scrie un
bloc de informaţii în bufer.
Structurile FILE. Dislocarea memoriei din bufer de tip intare /ieşire de un oarecare fişier este furnizat de
variabile de tip FILE. Acesta e dotat cu valori când un program deschide un fişier pentru a-l manipula . Tipul
FILE este definit ca o structură ,header <stdio.h>. Câmpurile asle conţin adresa tamponu-lui: un pointer spre
caracterul lui următor în bufer , numărul de carctere , starea fişierului (dreptul de acces, natura operaţiei efectuate
asupra fişierului ) şi descriptor . Descriptorul este un număr întreg care identifica fişierul dat .
Definiţia structurii FILE în < stdio.h> poate să varieze de la un sistem la altul , în ceea ce priveşte numărul
tipul, şi numărul câmpurilor . Ea conţine întotdeauna informaţii precedent descrise .

Typedef struct
{
char buffer; /* pointerul spre adresa tamponului */
char */ pointerrul spre caracterul următor în tampon */
int cnt; /* numărul de caractere în tampon */
int flags ; /* biţi dând starea fişierului */
int fd ; /* descriptorul */
} FILE;

Fişierul <stdio.h> conţine declaraţia unui tablou de oarecare structuri FILE. Fiecare element din acest tablou
este o variabilă structurată, care poate să stocheze informaţii relative la un fişier, sub forma precedent descrisă.
Pentru a acceda concret la un fişier în programul dat, trebuie de utilizat un pointer spre o variabilă de tip FILE.
Trebuie de definit pointerul: FILE * fp ; /* pointer spre variabila structurată FILE
Definiţia precedentă crează un pointer fp de tip pointer spre FILE, capabil de a memoriza adresa unei
variabile structurate FILE. Deoarece un fişier este deschis pentru a fi manipulat, funcţia competentă caută o
structură FILE disponibilă în tabloul precedent evocat. Adresa acestei variabile structurate este afectată la un
pointer ad.hoc, aşa ca fp.Toate accesele ulterioare se vor face prin intermediul acestui pointer.
Imaginea următoare ilustrează conexiunea între un program şi un fişier la care accedează programul:
Structurile
FILE

Pointer spre tampon

Poiter spre caracterul

următor în tampon

Numărul de acractere
în tampon

Descriptor

Pointer Scierea
FILE Citirea

Program tampon

Deschiderea fişierelor
Înainte ca un program să poată manipula un fişier , el trebuie să înceapă prin a-l deschide. Deschidereaunui
fişier pentru programul dat constă prin a deschide un acces cu ajutorul sistemului de exploatare :în caz de reuşită
el va acţiona aranjând într-o structură FILE în vederea operaţiilor ulterioare asupra fişierului . Toate aceste acţiuni
sunt efectuate prin funcţia predefinită fopen.

Iată prototipul funcţiei: File *fopen (char * nume_fişier,char*mod_ acces )

fopen returnează efectiv pointerul spre tipul FILE .Acest pointer o întoarce spre structură în care funcţia
aranjează informaţiile conţinute în fişierul deschis. Parametrul nume_fişier este un pointer spre şirul de
caractere ce conţine numele fişierului conţinut. Parametrul mod_acces este un pointer spre şirul de caractere ,
care indică natura operaţiilor pe care programul va trebui să-l execute după deschiderea fişierului. Să presupunem
că se doreşte să se deschidă un fişier .

Trebuie de început prin definirea pointerului FILE:

FILE */ defineşte un pointer FILE */

Pentru a efectua operaţia propriu-zisă:

Fp=fopen (xyz,dat, r): /* deschide fişierul */

Dacă ea reuşeşte , adresa structurii FILE conţinând informaţiile relative fişierului este afectat de pointerul Fp
Dacî fişierul nu-l va găsi în repertoriul indicat , funcţia fopen se fondează pe modelul r . El returnează atunci
valoarea NULL .
/* open xyz încearcă să deschidă fişierul xzy.dat */
#include <stdio.h > /* pentru FILE , open , printf */
main () {
FILE fp ; / defineşte pointerul fişierului */
if (( fp=fopen (xyz.dat, a))==NULL /* încearcă să deschidă fişierul */
printf ( eroare : imposibil de deschis fişierul /XYZ:dat /./n);
printf ( fişier / xyz.dat / deschide .n);
 În acest exemplu de program funcţia fopen nu reîntoarce pointerul nul dacă fişierul nu există. Din contra,
fişierul este creat în acest caz în repertoriul curent. Funcţia fopen returnează NULL dacă fişierul nu poate fi
deschis printr-o altă cale.

Fişierele texte şi fişierele binare

Conceptul de fişier-text corespunde la reprezentarea unui fişier sub forma unui şir de linii ; fiecare din ele,
fiind compuse dintr-un oarecare număr (0 la n) de caractere şi terminînd printr-un caracter special. Din contra un
fişier binar corespunde la un simplu şir de octeţi .
Un mare număr de sisteme de exploatare (aşa ca DOS) disting fişierele texte de cele binare nu doar la nivel
logic, dar şi la nivel fizic. Aceste reprezentaţii diferite de caracterul de la sfârşitul liniei în tampon şi în fişier au
poziţia X. Aceasta se traduce cam complicat , dacă fişierul text nu este manipulat , dar contrariu tratatelor de
acces direct . În efect în acest caz conversia caracterelor de la sfârşitul liniei nu a avut loc. Conţinutul fişierului de
tip text, se disting fizic, deoarece este interpretat ca fişier binar.
Caracterul de la sfârşitul liniei utilizat de fişiere texte poate pune probleme asupra numerelor sistemelor.
Pentru a deschide un fişier în mod binar trebuie de adăugat litera b la şirul de caractere care specifică modul său
de acces . Rb va semnifica că fişierul este deschis în mod binar şi în lectură . Dacă stringul care dă modul de acces
conţine un caracter +, atunci b poate să fie plasat înainte sau după semnul+.

Închiderea fişierelor
Când un fişier nu mai serveşte , el se poate închide. Legătura sa cu pointerul FILE corespunzător este
întrerupt. Funcţia nivelului înalt competent pentru a închide un fişier este fclose .Teoretic s-ar putea de renunţat să
apeleze explicit fclose în program . Fclose este chemat automatic la sfârşitul programului , pentru a închide toate
fişierele încă deschise.
Funcţia predefinită fclose admite prototipul: Int fclose (FILE *pointer_fişier);
Ea posedă ca parametru un pointer spre tipul FILE . Fclose returnează valoarea 0 dacă a putut să deschidă
fişierul ataşat la pointer_fiţier .
Următorul exemplu de program încearcă să deschidă un fişier a cărui nume e trecut pe linia de
comandă .Dacă va reuşi , fişierul este reînchis cu ajutorul funcţiei fclose
/* open close arată cum se deschide şi se închide un fişier a cărui nume a dat pe linia de comandă. */
#include stdio.h  /* printf , fopen , close */
#include stdlib.h /* exit */
#define READ “r”
main(int argc, char *argv )
 FI LE *fp;
If (argc! =2) /* un singur parametru admis */
 printf(?*=(“nsintaxa: opnclose fişier .exit/n”); exit(0); 
if ((fp=fopen (argv1, READ ))==NULL) /*deschiderea fişierului în citire */
printf(“EROARE:imposibil de deschis fişierul %s./n”, argv 1 );
else  fclose (fp); /* inchiderea fişierului */
printf (“fişierul %s a fost închis. /n”, argv 1 );


Operaţiile de citire şi de scriere
Pentru a citi sau a scrie datele unui fişier , se dispun de funcţii analogice a celor care servesc la prinderea
datelor la clavir şi la afişarea lor la ecran . Poziţia la care se citeşte sau se scrie într-un fişier este dat de un pointer
specific (seek pointer ), utilizat pentru operaţiile de lectură şi scriere. Acest pointer este condus de un sistem de
exploatare : el semnalează poziţia de tratare a mişcării într-un fişier. După fiecare lectură şi scriere acest pointer
este deplasat. Acest deplasament este efectuat prin sistem. Să presupunem că se citesc trei caractere (pe imaginea
următoare : A ,B, C) de un fişier X
SEEK pointer(citirea /scrierea )

A B C D E F G H
 // FisiereC_CURS1.DOC Lectura şi scrierea cu caractere
Funcţiile fputc şi fgetc permit de a scrie sau de a citi caracterele izolate în fişier.
Iată prototipul funcţiei fputc: Int fputc (intcaracter , FILE pointer _fişier).
Ea transferă un caracter dat ca prim parametru , în fişierul reprezentat prin pointer_fişier. Tipul caracterului
este convertit de int cu unsigned char. Valoarea fputc nu este altceva decât caracterul scris sau mai bine EOF în
caz de eroare .Să presupunem că este un pointer ataşat la un oarecare fişier , pointerul conţinând adresa structurii
FILE aferente. Deci instrucţia : Fputc(“A”, fp); /* scrierea unui caracter în fişier */
scrie caracterul A în fişierul ataşat la fp , la poziţia tratamentului curente.
Citirea cu caractere cu ajutorul funcţiei fgetc
Omologul funcţiei fputc este funcţia fgetc care citeşte un singur caracter în fişier.
Int fgetc (FILE * pointer_fişier); /* prototipul lui fgetc */
Funcţia fgetc returnează caracterul citit sub forma unei valori int. Dacă valoarea trimisă este EOF , sfârşitul
fişierului a fost atins sau are o eroare. Valoarea EOF explică de ce caracterul citit este returnat sub forma valorii
int şi nu valorii char.
Programul următor arată o aplicare elementară cu fgetc şi fputc. El scrie în fişier un text introdus de la
claviatură. Numele fişierului este introdus de utilizator .
/* keytofil scrie în fişier un text în lungime, introdus de la claviatură , apoi afişează la cerere. Operaţiile de I/E
în fişier utilizează funcţiile fgetc şi fputc. */
# include stdio.h /* fgetc, fputc, getchar , printf */
# include conio.h /* getche , getch */
# include ctype.h /* toupper */
# include stdlib.h /* exit */
#define END 64 /* caractere @ */
main () 
FILE *fp; /* pointer spre structura FILE */
char fillename 81; /* numele fişierului */
int I , repl, rep 2; /* variabila de control */
int c ; /* caracterul tampon */
printf (“Înregistrarea textului. Numele fişierului */n” );
do 
printf (“ /n Fişier :”); gets (file name);
if (( fp=fopen (filename, “r” )) !=NULL
 printf (“Fişierul existent. Să-l înlocuiască  (0/n)”); repl=getche(); repl=toupper (repl);
if (repl !=”0”) fclose (fp);  else /* fişierul nu mai există */ break; /*sfârşitul buclei */
 while ( repl==”0”);
if (fp !=NULL) /* fişier înlocuit ,deci : */ fclose (fp); /* se închide şi se redeschide în scriere */
if ((fp=fopen (filename , “w”))==NULL
 printf(“n imposibil de scris în fişier . /n” ); exit(1);  printf(“/n introduceţi textul”);
while ((c=getchar ()) !=END) /*scie textul în fişier */
fputf (c, fp); fclose (fp); /*** afişarea conţinutului fişierului: **********/
printf (De afişat fişierul (0/n”); rep2=getche(); rep2=toupper (rep2);
if (rep2==”o”)  if ((fp=fopen (file name, “r” )) ==NULL) 
printf(“/n Eroarea deschiderii fişierului. /n”); exit(2);
printf(“/n Conţinutul fişierului %s :/n “, filename); I=o;
While ((c= fgetc(fp)) !=EOF /*citirea caracterului în fişier */
 putchar(c); /* afişarea caracterului */
if (c==”/n”) /* numărul liniilor */ I++; If (I==20) /* nouă pagină pe toate 20 linii */
 printf (“/n Intrare pentru pagina următoare.” ); getch(); I=0; 
 /* fin while */ fclose (fp);  /* fin if rep2==”0” */ 

Comentarii: Programul dat verifică dacă fişierul în care trebuie de scris există deja. Pentru aceasta el
încearcă să-l deschidă. Dacă fişierul există funcţia fopen întoarce un pointer spre structura FILE. Dacă nu , el
trimite NULL. Şi dacă nu vrea să distrugă un fişier existent, îl închide şi se poate atunci de ales o altă denumire a
fişierului. Deci programul deschide fişierul în scriere şi utilizează funcţia fputc pentru a scrie textul ales de la
claviatură. Apoi fişierul este din nou închis . Dacă se doreşte să se afişeze conţinutul său fişierul este redeschis,
dar de această dată pentru a-l citi. Fiecare deschidere a fişierului în mod r sau w , plasează pointerul de pe poziţia
lui (seek pointer) la începutul fişierului. Acesta din urmă este întotdeauna citit, chiar de la început. În caz de
deschidere , pointerul va fi plasat la sfârşitul fişierului.
Pentru a citi datele de la claviatură , programul dat ,înlocuieşte cu funcţia getchar. Este un fişier periferic
în care se pot scrie datele , nu doar cu ajutorul funcţiei fputc sau putc.
 Fişierele periferice standarde şi pointerii FILE predefiniţi
Deobicei , în pornirea unui program în limbajul C sunt automatic deschişi 5 fişiere periferice aşa ca:
1. intrarea standard
2. ieşirea standard
3. ieşirea standard pentru erori
4. fişierul special de intrare/ieşire auxiliar
5. imprimanta standard
În principiu , intrarea standard este claviatura , iar ieşirea standard este ecranul . Ieşirea ierorilor standard este
constituit din ecran . Un fişier special suplementar este prevăzut pentru operare de I/E efectuate printr-un periferic
conectat în serie .Se poate de modificat afecţiunea fişierelor speciale standard la perifericile , pe care noi vrem să
le evocăm.
Rezumatul care urmează arată relaţia între pointerii FILE predefiniţi şi fişierele periferice:
Imprimanta standard permite de a dirija datele spre o imprimantă. Pentru aceste 5 fişiere speciale este definit
în stdio.h un pointer FILE care o întoarce spre o structură FILE adecvată şi care este ataşat fişierului periferic
concernat. Denumirile acestor pointeri FILE sunt: stdin, stdout , stdrn , stdaux şi stdrn . Ultimii nu sunt pointeri
variabili , ci pointeri constante de tip FILE . Ca şi toate constantele , pointerii constante FILE nu sunt lvalue
Pointer Fişier periferic

Stdin Intrarea standard

Stdout Ieşirea standard

Stderr Ieşirea p/u erori

Stdaux Fişier special de I/E

Stdprn Imprimanta standard

Un canal special pentru analiza erorilor

Ieşirea erorilor standard ne prezintă un fişier special de ieşire , destinat pentru recuperarea mesajelor de eroare
.În general ieşirea erorilor standard este ataşată la ecran , de ieşire care afişează datele pe monitor spre un alt canal
, ieşirea standard.

Se dau exemplele următoare de variabile:

File */ fp;
Int I=0;
Char eroare în mesaj [ ] =”eroare la deschiderea fişierului .”;

S-ar putea deci de înlocuit formularea deschiderii fişierului xyz.dat:

If ((fp=fopen (“xyz.dat”, “r”))==NULL)

Prin noua scriere :

If ((Fp =fopen (“xyz.dat”, “R”))==NULL)

While (eroare mesaj [ i])
Fputc(eroare mesaj [I++], stderr);

În acest caz , afişarea masajului eroare nu se face spre funcţia stdout, dar stderrr

Afişarea caracterului de caracterul mesaj de eroare prin funcţia fput c poate fi puţin complicat.

Direcţiile de intrare şi de ieşire

Se întreabă dacă canalul de ieşire rezervat mesajelor erori este într-adevăr indispensabil. El este în cazul unde
intrările-ieşirile unui program sunt redirijate. I/E standard nu mai sunt reprezentate de claviatură /ecran , dar de un
fişier ordinar. Să considerăm ,deci, următorul exemplu de program:
/* finout recopie intrarea standard la ieşirea standard */
 #include <stdio.h> /* fgetc, fputc, feof */
main ()
{

char mesaj [] = “/n eroare în citire ./n”;

int I=0;
int c;
while ((c=fgetc (stdin)) !=EOF)
fputc(C, stdout );
if (!feof (stdin)) /* eroare în citire */
while (mesaj [i] )
fputc (mesaj [I++], stdout);

Citirea şi scrierea în lanţ

Se cunosc funcţiile gets şi puts care citesc/ scriu un şir de caractere la I/E standard . Funcţia fgets citeşte un şir
de caractere într-un fişier. Iată prototipul fgets:
char fgets (char pointer_tampon int număr , FILE pointer_fişier ).
Aici pointer_bufer  trimite buferul utilizat pentru stocarea şirului de caractere citit .pointer_fişier
indică pointerul FILE ataşat la fişier , pe care trebuie să-l citească . Funcţia fgets returnează un pointer la
începutul buferului conţinând şirul de caractere citit. În ceea ce priveşte valorii returnate NUL fgets se comporta
ca fgets cu EOF: se poate deci de utilizat feof pentru a verifica dacă valoarea returnată semnalează o eroare .
Funcţia fget citeşte în fişier un oarecare număr de caractere şi le aranjează în locul memoriei prin
pointer_tampon, până ce se produce una din evenimentele următoare.
Fgets întâlneşte caracterul noii linii, funcţia se termină. Iată de ce fgets se pregăteşte bine la citirea liniei
într-un fişier .

Duplicarea fişierelor cu ajutorul funcţiei fgets şi fputs

Programul care urmează utilizează funcţii fgets şi fputs pentru duplicarea fişierelor texte. Numele
fişierului copiat este trecut ca parametru pe linia de comandă. Un apel de tcopy:

/’ tcopy copie un fişier text cu ajutorul funcţiilor fgets şi fputs. */

/* tcopy este lansat ca la sintaxă : tcopy sursa principală. */
/* Programul nu verifică, în această versiune ci o copie */
/* fişier ezistent.
# include <stdio.h> /* fopen, fclose all, fgets, fputs */
#include <stdlib,h> /’ exit, toupper */
#include <string.h> /* strcmp */

#define SYNTAX “sintaxa : tcopy sursa principală /n”/

“ Tcopy CON principal /n”
“ tcopy sursa CON”

#define NOREAD “imposibil de deschis fişierul principal .”

#define NOWRITE “imposibil de deschis fişierul principal”
#define NOCOPY “ imposibil de duplicat un fişier pe el însăşi.”

void upstr (char s ); / conversia unui lanţ în majuscule */

main (int argc, char *argv [])
{ file * infile =stdin; //’pointerul spre fişierul sursă: iniţializat la “stdin” pentru cazul unde lectura se face la claviatură.
file outfile = stdout;//pointer spre fişierul principal:iniţialiyat la “stdout” pentru cazul scrierea se face la ecran .
char sbuf [512]; /* tampon de citire / scriere */ int I;
if (argc !=3) /* trebuie de dat o sursă ! */ { fputs (SYNTAX, stderr); exit (1); }
for (I=1; I<3) /* convertirea parametrilor pe linia de comandă */ upstr (argv[1]):
if (! Strcmp (argv [1], argv [2]) /’ sursa =cible */ { fputs (NOCOPY,stderr); exit (2); }
if (strcmp (argv [1], “con”) /* sursa !=claviatura */
{ if (infile = fopen (argv [1], “R”))==NULL) { fputs (NOREAD, stderr); exit (3); } }
if (strcmp (argv [2, “CON] if (! Strcmp (argv [2]) /’ sursa =cible */ { fputs (NOCOPY,stderr); exit (2); }
if (strcmp (argv [1], “con”) /* sursa !=claviatura */ {
if (infile = fopen (argv [1], “R”))==NULL) { fputs (NOREAD, stderr); exit (4); }}
/* duplicare *7
WHILE (fgets (sbuf, 512, infile) !=NULL) Fputs (sbuf, outfile ); Fcloseall(); /* se închid fişierele /* }
void upstr (char s) / converteşte stringul in majuscule */ { int I=0;
while (S[i]) { S [i]=toper (S[i]); I++; } }

Citirea şi scrierea formatelor

Funcţiile fprintf şi fscanf permit de a efectua scrierea sau citirea formatelor de date în fişier . Cele două
funcţii lucrează practic ca funcţii de terminal printf ţi scanf .În particular ele folosesc formatări . Singura diferenţă
este că printf şi scanf reclamă un pointer FILE în mai mult de un lanţ de format şi alţi parametri efectivi.
Printf este o funcţie care acceptă un număr variabil de parametri , returnează ca rezultat numărul de
caractere scrise.
Fscanf este o funcţie care citeşte datele în fişier , formatându-le.

Citirea formatelor într-un fişier cu ajutoril funcţiei :fscanf

Funcţia fscanf citeşte date din fişier formatându-le. Ea admite prototipul:

Int fscanf (FILE * <pointer fişier >, char *< lanţ format >,…);
Funcţia fscanf dă ca rezultat numărul de date corect citite . Valoarea de retur EOF signalează la sfârşitul
fişierului o eroare.
Dacă a definit prototipul variabilelor:
Long no ; /* cod client */
Char nom [31]; /* numele clientului */
Long cp ; /* cod poştal */
Char oraş [31 ]; cifrele de afaceri */

Atunci instrucţia :

If ((fp=fopen (“ clienţi.dat”,”R”)) ==NULL) fputs (“ imposibil de a deschide fişierul.”, stderr);

Else While (fscanf (fp, “%1d%30s %1d %30s %f”, /no , nume, /cp, oraş,
/ca)==%5)
printf (“% 1d %s %. 2f / n /!,no, nume,cp, oraş ,ca);
citeşte şi afişează înregistrările din fişier dat, până ce survine o eroare , sau la sfârşitul fişierului să fie
atent

Citirea şi scrierea în bloc

Funcţiile de intrare /ieşire sunt adaptate tratamentelor de entităţi de diferite tipuri , care citeşte sau scrie într-
un fişier de caractere , şiruri sau valori numerice. Dar cu funcţiile fread şi fwrite , se dispun de 2 funcţii care
permit de a transfera spre un fişier , nu numai de entităţi complete , dar şi din contra , un număr oarecare de
octeţi.

Scrierea blocurilor în fişier cu funcţia f write:

Funcţia fwrite admite prototipul:

Size t fwrite (void * pointer tampon, size_t taille

Size_t număr, FILE */pointer_fişier);

Ea scrie un bloc de taille * număr octeţi aranjaţi în locul memoriei referenţiate prin pointer_tampon
în fişierul ataşat la pointer_fişier. Blocul se compune din număr de obiecte, fiecare din ele fiind de
dimensiuni taille. Valoarea returnată de fwrite este egală cu numărul de date complet recopiate în fişier . În caz
de eroare , fwrite trimite o valoare inferioară la număr. Tipul size t este definit în stdio.h ca total
neănsemnat şi şi câtevai headere. Pointerul pointer_tampon este de tip void *, şi poate conţine adresa blocului
de date de tip oarecare.
 Se folosesc
metode de
Modelul conceptual acces
eleme-tar

inferior
Fişier sub
forma
unui şir Mai puţin
de octeţi elementar

Fişiere niveluri
binare Este o
Fişier mulţime
sub de date
forma Fişiere superior
Caracteristici
unui şir texte
de linii Fişier Tablou
gigantic

nu e necesar operaţii
de a daclan-
şa operaţii
Are forma are elemente
de I/E unui şir co- de aceeaşi
tinuu de natură
octeţi De
Noneleme
citire
-tare

Se citeşte cu
Informaţi
De scriere ajutorul
a trece
pointerului
prin bufer
seek
Fiecare
operaţie scrie De f-ii care
un bloc de le afişează
informaţii la ecran
Dispun de
funcţii care
prind datele
la clavir
Modelul structural-funcţional
Fişiere

Caracteristica

O mulţime de date Tablou gigantic Conţine elemente Are forma unui şir Fişiere texte Fişiere binare
de aceeaşi natură continuu de caractere

Datele sunt conser- Fiecare program Au conţinut Fiecare caracter e Fişier sub forma Fişier sub forma
vate pe un suport citeşte sau scrie datele omogen localizat prin index unui şir de linii unui şir de octeţi

operaţii niveluri

nonelementare De scriere De citire superior inferior

Fiecare operaţie Dispun de funcţii Citeşte cu Se folosesc Se folosesc

scrie un bloc de care prind datele de ajutorul elemente metode de
informaţii la clavir şi le afişă la pointerului seek elementare acces elementar
ecran
Concluzie: Pe parcursul întregului curs de lecţii la „Modelarea sistemelor” am realizat abordări sistemice ale unor obiecte
studiate anterior în cadrul altor materii de studiu. Am efectuat studiul sistemelor, obiectelor şi modelarea lor pe baza
principiilor euristice sau a cunoştinţelor din obiectele studiate anterior.
Flexibilitatea organizării structurale în baza conceptelor modelelor este corespunzătoare mediilor de creştere masivă
sau radicalizat.
Pe parcursul elaborării modelelor conceptuale ale sistemelor pot fi utilizate diverse metodologii. De exemplu:
metodologia Jemkins, metodologia Rand, metodologia Checkland, şi altele.
În urma efectuării lucrării am analizat obiectul de studiu –fişiere.În urma analizei, pe baza metodologiilor de studiu ,
am elaborat modelul conceptual şi structural-funcţional. Am utilizat metodologie simbolică.
Am elaborat un program în limbajul Pascal care citeşte din program informaţia despre fişiere., după ce se va studia
notele de curs. Ceea ce am învăţat pe parcursul anului de studiu m-a ajutat să înţeleg unele noţiuni , care erau necunoscute
pâna acum. Aceste cunoştinţe îmi vor fi de folos în continuare, care mă vor ajuta să concep mai bine sistemul.
Bibliografie1.Language C
Descrierea programului. Am realizat un program în limbajul Pascal , care citeşte din program informaţia despre fişier.
La execuţia programului ne apare un meniu textual , care ne prezintă cele opt opţiuni , care descrie fişiere. Teoria despre
fişiere grupate , conform opţiunilor prezentate. La alegerea unei opţiuni se va deschide o altă fereastră în care se află teoria
corespunzătoare .
Procedura numit graf iniţiază grafica programului .
Procedura show meniu afişează interfaţa meniului.
Procedura citire- citeşte informaţia despre fişiere pe paragrafe.
A noua opţiune indică ieşirea din interfaţa meniului şi revenirea la listingul programului.
Un fişier nu este altceva decât o mulţime mai mult sau mai puţin importante de date , conservate pe un oarecare suport.
În ceea ce priveşte limbajul C , se poate de reprezentat un fişier ca un tablou gigantic permanent , în care un program poate să
scrie sau să citească datele. Un fişier trebuie să conţină elemente de aceeaşi natură , de un conţinut omogen . Contrar altor
limbaje , conţinutul unui fişier C nu este structurat la timp . Are forma unui şir de caractere(octeţi). Iată de ce un fişier este
câteodată denumit flux de donaţii . Fiecare caracter (octet conţinând caracterul ) luat individual poate fi localizat în fişier
printr-un index . Mai mult ca atât ca un fişier să fie considerat ca un şir nonstructurat de octeţi , îi încredinţează
programatorului să creeze o structură de fişiere aşa ca datele să fie administrate cum îl aud. Pentru aceasta dispune de o
serie de funcţii adaptate , care îi permit să manipuleze datele de toate dimensiunile şi de toate tipurile. Fişierele are o serie de
operaţii, dintre care cele mai elementare fiind cele de citire şi de scriere, operaţii neelementare. Are două niveluri: inferior şi
superior. La nivel inferior se folosesc metode cu acces elementar, iar la nivelul superior se folosesc elemente elementare.
Sunt două tipuri de fişiere:
 Fişiere texte
 Fişiere binare
Fişierele texte sunt acele fişiere sub forma unui şir de linii, iar cele binare sunt sub forma unui şir de caractere.
Exemple de rezultate:
La alegerea uneia din opţiunile date se afişează teoria corespunzătoare . Ca exemplu putem lua “Note de curs”:
Un fişier nu este altceva decât o mulţime mai mult sau mai puţin importante de date , conservate pe un oarecare
suport. În ceea ce priveşte limbajul C , se poate de reprezentat un fişier ca un tablou gigantic permanent , în care un program
poate să scrie sau să citească datele. Un fişier trebuie să conţină elemente de aceeaşi natură , de un conţinut omogen . Contrar
altor limbaje , conţinutul unui fişier C nu este structurat la timp . Din contra aceste donaţii sunt simplu aranjate sub forma
unui şir de caractere(octeţi). Iată de ce un fişier este câteodată denumit flux de date.
Alt exemplu se poate de luat “Operaţiile de citire şi de scriere”
Pentru a citi sau a scrie datele unui fişier , se dispun de funcţii analogice a celor care servesc la prinderea datelor la
clavir şi la afişarea lor la ecran . Poziţia la care se citeşte sau se scrie într-un fişier este dat de un pointer specific (seek pointer
), utilizat pentru operaţiile de lectură şi scriere. Acest pointer este condus de un sistem de exploatare : el semnalează poziţia
de tratare a mişcării într-un fişier.