Cu exemple de fișiere și șiruri de caractere. Intrare din fișier și ieșire în fișier

Fișiere text

Să ne uităm la lucrul cu un fișier text în C folosind un exemplu. Creați un fișier text pe unitatea C denumit TextFile.txt. Introduceți următoarele rânduri în acest fișier:

String_1 123 String_11, 456
String_2
String_3

Salvați fișierul.

Și acesta este codul pentru un program C care deschide fișierul nostru și citește linii din el:

/* *Autor: @author Subbotin B.P..h> #include #define LEN 50 int main(void) (puts("Operațiuni cu fișierul text"); char cArray; FILE *pTextFile = fopen("C:\\TextFile.txt", "r"); if(pTextFile == NULL) ( puts("Probleme"); return EXIT_FAILURE; ) while(fgets(cArray, LEN, pTextFile) != NULL) ( printf("%s", cArray); ) fclose(pTextFile return EXIT_SUCCESS);

Pentru a deschide un fișier text în C, utilizați funcția fopen:

FIȘIER *pTextFile = fopen("C:\\TextFile.txt", "r");

Primul argument al funcției fopen indică un fișier, iar al doilea spune că fișierul este deschis pentru citire din el.

Citim liniile folosind funcția fgets:

fgets(cArray, LEN, pTextFile);

Primul argument al funcției fgets indică o matrice de caractere în care vor fi stocate șirurile primite, al doilea argument este numărul maxim de caractere de citit, iar al treilea este fișierul nostru.

După ce ați terminat de lucrat cu fișierul, trebuie să îl închideți:

fclose(pTextFile);

Primim:

În rânduri apar și litere rusești.

Apropo, am făcut acest program în Eclipse. Puteți vedea cum să lucrați cu C/C++ în Eclipse.

Deci, am deschis și am citit datele dintr-un fișier text.

Acum vom învăța cum să creăm programatic un fișier text și să scriem date în el.

/* Autor: @author Subbotin B.P..h> #include int main(void) ( FILE *pTextFile = fopen("C:\\TextFileW.txt", "w"); char *cString = "Acesta este un șir"; char cNewLine = "\n"; int nVal = 123 ; if(pTextFile == NULL) (puts("Probleme"); return EXIT_FAILURE; ) fprintf(pTextFile, "%s%c", cString, cNewLine);

Creați un fișier text în care să scrieți date:

FIȘIER *pTextFile = fopen("C:\\TextFileW.txt", "w");

dacă fișierul există deja, acesta va fi deschis și toate datele din acesta vor fi șterse.

C-string cString și numărul nVal sunt scrise de program într-un fișier text. cNewLine este pur și simplu o linie nouă.

Scriem date într-un fișier text folosind funcția fprintf:

fprintf(pTextFile, „%s%c”, cString, cNewLine);

primul argument aici este fișierul nostru, al doilea este șirul de format, al treilea sau mai multe este numărul de argumente necesare pentru acest format.

Pentru a facilita accesul, informațiile din dispozitivele de stocare sunt stocate sub formă de fișiere.

Un fișier este o zonă numită a memoriei externe alocată pentru stocarea unei matrice de date. Datele conținute în fișiere sunt de natură foarte diversă: programe în limbaj algoritmic sau mașină; date inițiale pentru funcționarea programului sau rezultatele execuției programului; texte libere; imagini grafice etc.

Director (dosar, director) - o colecție numită de octeți pe un mediu de stocare care conține numele subdirectoarelor și fișierelor, utilizate în sistemul de fișiere pentru a simplifica organizarea fișierelor.

Sistemul de fișiere numită partea funcțională a sistemului de operare care efectuează operațiuni asupra fișierelor. Exemple de sisteme de fișiere sunt FAT (FAT - File Allocation Table), NTFS, UDF (utilizat pe CD-uri).

Există trei versiuni principale de FAT: FAT12, FAT16 și FAT32. Ele diferă prin adâncimea de biți a înregistrărilor din structura discului, adică numărul de biți alocați pentru a stoca numărul clusterului. FAT12 este folosit în principal pentru dischete (până la 4 KB), FAT16 pentru discuri de capacitate mică, FAT32 pentru unități FLASH de mare capacitate (până la 32 GB).

Să ne uităm la structura sistemului de fișiere folosind FAT32 ca exemplu.

Structura fișierului FAT32

Dispozitivele de memorie externe din sistemul FAT32 au mai degrabă adresare bloc decât adresare octet. Informațiile sunt scrise pe un dispozitiv de memorie extern în blocuri sau sectoare.

Un sector este unitatea minimă adresabilă de stocare a informațiilor pe dispozitivele de stocare externe. De obicei, dimensiunea sectorului este fixată la 512 octeți. Pentru a mări spațiul de adrese al dispozitivelor de memorie externe, sectoarele sunt combinate în grupuri numite clustere.

Un cluster este o unire a mai multor sectoare, care poate fi considerată ca o unitate independentă cu anumite proprietăți. Proprietatea principală a unui cluster este dimensiunea sa, măsurată în numărul de sectoare sau numărul de octeți.

Sistemul de fișiere FAT32 are următoarea structură.

Clusterele utilizate pentru scrierea fișierelor sunt numerotate începând de la 2. De regulă, clusterul nr. 2 este folosit de directorul rădăcină, iar începând de la clusterul nr. 3 se stochează matricea de date. Sectoarele utilizate pentru stocarea informațiilor deasupra directorului rădăcină nu sunt grupate.
Dimensiunea minimă de fișier necesară pe disc corespunde unui cluster.

Sectorul de boot începe cu următoarele informații:

• EB 58 90 – săritură necondiționată și semnătură;
• 4D 53 44 4F 53 35 2E 30 MSDOS5.0;
• 00 02 – numărul de octeți din sector (de obicei 512);
• 1 octet – numărul de sectoare din cluster;
• 2 octeți – numărul de sectoare de rezervă.

În plus, sectorul de boot conține următoarele informații importante:

• 0x10 (1 octet) – numărul de tabele FAT (de obicei 2);
• 0x20 (4 octeți) – numărul de sectoare de pe disc;
• 0x2С (4 octeți) – numărul de cluster al directorului rădăcină;
• 0x47 (11 octeți) – etichetă de volum;
• 0x1FE (2 octeți) – semnătura sectorului de pornire (55 AA).

Sectorul de informații despre sistemul de fișiere conține:

• 0x00 (4 octeți) – semnătură (52 52 61 41);
• 0x1E4 (4 octeți) – semnătură (72 72 41 61);
• 0x1E8 (4 octeți) – numărul de clustere libere, -1 dacă necunoscut;
• 0x1EC (4 octeți) – numărul ultimului cluster înregistrat;
• 0x1FE (2 octeți) – semnătură (55 AA).

Tabelul FAT conține informații despre starea fiecărui cluster de pe disc. Cei 2 octeți inferiori ai tabelului FAT stochează F8 FF FF 0F FF FF FF FF FF (care corespunde stării clusterelor 0 și 1, care sunt absente fizic). În continuare, starea fiecărui cluster conține numărul clusterului în care fișierul curent continuă sau următoarele informații:

• 00 00 00 00 – clusterul este liber;
• FF FF FF 0F – sfârșitul fișierului curent.

• 8 octeți – numele fișierului;
• 3 octeți – extensia fișierului;

Directorul rădăcină conține un set de înregistrări de informații pe 32 de biți despre fiecare fișier, care conține următoarele informații:

Când lucrați cu nume lungi de fișiere (inclusiv nume rusești), numele fișierului este codificat folosind sistemul de codare UTF-16. În acest caz, 2 octeți sunt alocați pentru codificarea fiecărui caracter. În acest caz, numele fișierului este scris în următoarea structură:

• 1 octet secvență;
• 10 octeți conțin cele 5 caractere inferioare ale numelui fișierului;
• atribut de 1 octet;
• 1 octet rezervat;
• 1 octet – suma de control al numelui DOS;
• 12 octeți conțin cele 3 caractere inferioare ale numelui fișierului;
• 2 octeți – numărul primului cluster;
• caracterele rămase ale numelui lung.

Lucrul cu fișiere în limbaj C

Pentru programator, un fișier deschis este reprezentat ca o secvență de date citite sau scrise. Când un fișier este deschis, acesta este asociat cu Fluxul I/O. Informațiile de ieșire sunt scrise în flux, informațiile de intrare sunt citite din flux.

Când un flux este deschis pentru I/O, acesta este asociat cu o structură FILE standard, care este definită în stdio.h. Structura FILE conține informațiile necesare despre fișier.

Deschiderea unui fișier se face folosind funcția fopen(), care returnează un pointer către o structură de tip FILE care poate fi folosită pentru operațiunile ulterioare asupra fișierului.

FIȘIER *fopen(nume, tip);

nume – numele fișierului de deschis (inclusiv calea),
type este un pointer către un șir de caractere care definește modul în care este accesat fișierul:

• "r" - deschideți fișierul pentru citire (fișierul trebuie să existe);
• "w" - deschideți un fișier gol pentru scriere; dacă fișierul există, conținutul acestuia se pierde;
• "a" - deschideți fișierul pentru scriere până la sfârșit (pentru anexare); fisierul este creat daca nu exista;
• "r+" - deschideți fișierul pentru citire și scriere (fișierul trebuie să existe);
• "w+" - deschideți un fișier gol pentru citire și scriere; dacă fișierul există, conținutul acestuia se pierde;
• „a+” - deschideți fișierul pentru citire și adăugare dacă fișierul nu există, atunci acesta este creat;

Valoarea returnată este un pointer către fluxul deschis. Dacă se întâlnește o eroare, este returnat NULL.

Funcția fclose() închide fluxul sau fluxurile asociate fișierelor deschise folosind funcția fopen(). Fluxul de închis este determinat de argumentul funcției fclose().

Valoare returnată: valoarea 0 dacă fluxul a fost închis cu succes; EOF constantă dacă a apărut o eroare.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

#include
int main() (
FIȘIER *fp;
numele caracterului = "my.txt" ;
if ((fp = fopen(nume, "r" )) == NULL )
{
printf( "Deschiderea fișierului a eșuat");
getchar();
întoarce 0;
}
// am reușit să deschid fișierul
... // acțiuni necesare asupra datelor
fclose(fp);
getchar();
întoarce 0;
}

Citirea unui caracter dintr-un fișier:

char fgetc(stream);

Argumentul funcției este un pointer către un flux de tip FILE. Funcția returnează codul caracterului citit. Dacă se ajunge la sfârșitul fișierului sau apare o eroare, este returnată constanta EOF.

Scrierea unui simbol într-un fișier:

fputc(char, stream);

Argumentele funcției sunt un caracter și un pointer către un flux de tip FILE. Funcția returnează codul caracterului citit.

Funcțiile fscanf() și fprintf() sunt similare cu funcțiile scanf() și printf(), dar funcționează cu fișiere de date și au un pointer către fișier ca prim argument.

fscanf(stream, "InputFormat", argumente);

Pentru programator, un fișier deschis este reprezentat ca o secvență de date citite sau scrise. Când un fișier este deschis, acesta este asociat cu Fluxul I/O . Informațiile de ieșire sunt scrise în flux, informațiile de intrare sunt citite din flux.

Când un flux este deschis pentru I/O, acesta este asociat cu o structură FILE standard, care este definită în stdio.h. Structura FILE conține informațiile necesare despre fișier.

Deschiderea unui fișier se face folosind funcția fopen(), care returnează un pointer către o structură de tip FILE care poate fi folosită pentru operațiunile ulterioare asupra fișierului.

FIȘIER *fopen(nume, tip);

nume – numele fișierului de deschis (inclusiv calea),
tip - indicator către un șir de caractere care definește modul în care este accesat fișierul:

· „r” - deschideți fișierul pentru citire (fișierul trebuie să existe);

· "w" - deschide un fișier gol pentru scriere; dacă fișierul există, conținutul acestuia se pierde;

· „a” - deschideți fișierul pentru scriere până la sfârșit (pentru anexare); fisierul este creat daca nu exista;

· „r+” - deschideți fișierul pentru citire și scriere (fișierul trebuie să existe);

· „w+” - deschideți un fișier gol pentru citire și scriere; dacă fișierul există, conținutul acestuia se pierde;

· „a+” - deschideți fișierul pentru citire și adăugare dacă fișierul nu există, atunci acesta este creat;

Valoarea returnată este un pointer către fluxul deschis. Dacă este detectată o eroare, este returnat NULL.

Funcția fclose() închide fluxul sau fluxurile asociate fișierelor deschise folosind funcția fopen(). Fluxul de închis este determinat de argumentul funcției fclose().

Valoare returnată: valoarea 0 dacă fluxul a fost închis cu succes; EOF constantă dacă a apărut o eroare.

#include
int main()

char name="my.txt";

if(fp = fopen(nume, "r")!=NULL)

// a fost posibil să deschidem fișierul?
... // acțiuni necesare asupra datelor

else printf("Deschiderea fișierului a eșuat");

Citirea unui caracter dintr-un fișier:

char fgetc(stream);

Argumentul funcției este un pointer către un flux de tip FILE. Funcția returnează codul caracterului citit. Dacă se ajunge la sfârșitul fișierului sau apare o eroare, este returnată constanta EOF.
Scrierea unui simbol într-un fișier:

fputc(char, stream);

Argumentele funcției sunt un caracter și un pointer către un flux de tip FILE. Funcția returnează codul caracterului citit.

Funcțiile fscanf() și fprintf() sunt similare cu funcțiile scanf() și printf(), dar funcționează cu fișiere de date și au un pointer către fișier ca prim argument.

fscanf(stream, „Format de intrare”, argumente);
fprintf(stream, „Format de ieșire”, argumente);

Funcțiile fgets() și fputs() sunt concepute pentru intrarea/ieșirea șirurilor de caractere sunt analoge cu funcțiile gets() și puts() pentru lucrul cu fișiere.

fgets(Pointer To Line, Numar de caractere, flux);

Caracterele sunt citite din flux până când este citit un caracter de nouă linie „\n”, care este inclus în șir, sau până când fluxul se termină EOF sau a fost citit numărul maxim de caractere. Rezultatul este plasat într-un indicator și se termină cu caracterul nul „\0”. Funcția returnează adresa șirului de caractere.

fputs(Pointer To String, flux);

Copiază un șir în flux din poziția curentă. Caracterul nul final nu este copiat.
Exemplu Introduceți numărul și salvați-l în fișierul s1.txt. Citiți numărul din fișierul s1.txt, creșteți-l cu 3 și salvați-l în fișierul s2.txt.

Am învățat deja cum să scriem informații într-un fișier text. – Dacă nu ați învățat cum, consultați articolul anterior. Este spus și descris în detaliu

Dar dacă fișierul există deja și trebuie să citim informații din el pentru procesare? Din fericire, acest lucru este și destul de simplu. Permiteți-mi să vă reamintesc că există mai multe opțiuni pentru implementarea acestei sarcini, am descris doar una dintre ele. Cel descris este cel care din anumite motive mi se pare personal cel mai ușor de înțeles.

#include

int main()
{
char s1 //Variabila va citi șirul
ifstream în (“C:\\\FromC\\myfile.txt”); //Deschideți fișierul pentru a citi informații
în >>s1 ; //citește rândul
in.close() //Închiderea dosarului

cout<Ieșiți valoarea s1 la ecran
returnează 0;
}

Iată cel mai simplu program pentru a citi prima linie dintr-un fișier text situat de-a lungul căii
C:\\\FromC\\myfile.txt –
Deoarece aceasta este o continuare a articolului anterior, am decis să folosesc fișierul pe care l-am creat acolo. Probabil că nu ar trebui să existe dificultăți cu asta.
Dar să revenim la cod. Mai întâi deschidem fișierul pentru a citi informațiile din acesta, pentru aceasta folosim comanda ifstreamîntre paranteze indicăm fie numele fișierului, fie calea către fișier, așa cum am făcut eu. („C:\\\FromC\\myfile.txt”);
Când am deschis un fișier pentru a citi ceva din el, am declarat o variabilă ca char –
char s1
Acum tot ce trebuie să facem este să atribuim variabilei valoarea șirului din fișier. Facem asta ca o echipă în
Acordați atenție colțurilor în >>
De fapt, după cum se vede din comentariile la codul programului, pentru ca variabila să atribuie valoarea citită, trebuie să o scriem după în >>
în >>s1 ;

Aceasta nu pare a fi o sarcină deosebit de dificilă, mai ales dacă ați stăpânit deja perfect și ați învățat să utilizați materialul din articolul anterior - totul este absolut la fel, doar 2 comenzi sunt diferite

Crearea unui fișier și scrierea informațiilor C++ în el

ofstream afară ( Nume de fișier );
afară<< (Șir de scris);
afară.închide();
=============================

Citirea textului dintr-un fișier și tipărirea textului pe ecran în C++

ifstream în (Nume de fișier );
în>> (Citind rândul);
în.închide();(Închide fișierul)
============================
Să scriem un program simplu care va citi textul introdus de la tastatură și îl va scrie într-un fișier:

#include
#include

int main()
{
\\ 3 rânduri viitoare
clrscsr(); //Ștergerea ecranului

cout<<“Wwedi pervuu stroku” ; cin >>a ; endl ;
cout<<“Wwedi wtoruu stroku” ; cin >>b ; endl ;
cout<<“Wwedi tretuu stroku” ; cin >>c ; endl ;
clrscr(); //

/*Începe să lucrezi cu fișierul*/
ofstream out („C:\\\FromC\\myfile.txt”); //Deschiderea unui fișier pentru scriere
afară<Notează prima linie
afară<Scrie a doua linie
afară<Notează a treia linie
out.close(); //Închiderea dosarului

//Resetează variabilele la zero

pentru (int i =0;i<=255 ;i ++)
(a =*“” ; b =*“” ; c =*“” ;)

ifstream in(„C:\\\FromC\\myfile.txt”);
în >>a >>b >>c ; //Citim fiecare rând nou într-o nouă variabilă
in.close(); //Închiderea dosarului

/* */

pentru (i =0 ;a !=*“” ;i ++)
{
dacă (i >dimensiunea(a)) pauză ;
cout<
}
cout<<“\n” ; \\

/* */

{
dacă (i > dimensiunea (b)) pauză ;
cout<
}
cout<<“\n” ; \\ A mutat cursorul pe o linie nouă

/* */

pentru (i =0 ;с !=*“” ;i ++)
{
dacă (i >dimensiunea(c)) pauză ;
cout<<с ;
}

returnează 0;
}
===================

În exemplele de mai sus există unul astfel IMENS defect. Dacă încercăm să introducem o linie care conține spații, programul nu va funcționa așa cum avem nevoie. Probabil, nu numai eu, ci și mulți alți oameni am dat peste această eroare. Prin urmare, las codul incorect, astfel încât să puteți vedea ce ați putea întâlni.

Din moment ce nu există cărți acasă, am început din nou să caut pe internet și am găsit o mulțime de tot felul de prostii sofisticate. Dar cumva am găsit o soluție la problema mea.
M-a ajutat să citesc asta cout susține metodele sale. Și pe Internet toate sfaturile se referă la utilizarea funcției getline Din fericire pentru mine, am aflat foarte repede cum să folosesc această funcție și apoi am folosit-o în cod.
În general, merită menționat și descris această funcție, dar până acum nu prea o înțeleg, doar înțeleg că trebuie folosită și înțeleg cum, așa că voi da un exemplu mai corect al programului nostru în curs de dezvoltare :

#include
#include

int main()
{
char a,b,c; \\ 3 rânduri viitoare
clrscsr(); //Ștergerea ecranului

/* Introduceți valori pentru variabile*/

cout<<“Wwedi pervuu stroku” ; cin.getline(a,sizeof(a)); endl ;
cout<<“Wwedi wtoruu stroku” ; cin.getline(a,sizeof(b)); endl ;
cout<<“Wwedi tretuu stroku” ; cin.getline(a,sizeof(c)); endl ;
clrscr(); //După introducerea valorilor, ecranul a fost șters

/*Începe să lucrezi cu fișierul*/
ofstream out („C:\\\FromC\\myfile.txt”); // Deschiderea unui fișier pentru scriere
afară<Notează prima linie
afară<Scrie a doua linie
afară<Notează a treia linie
out.close(); //Închiderea dosarului

//Resetează variabilele la zero

pentru (int i =0;i<=255 ;i ++)
(a =*“” ; b =*“” ; c=*“” ;)

/*Continuați să lucrați cu fișierul*/

dacă flux în („C:\\\FromC\\myfile.txt”);
in.getline(a,sizeof(a));// A
in.getline(b,sizeof(b));// Citirea unei linii într-o variabilă b
in.getline(c,sizeof(c)); // Citirea unei linii într-o variabilă c
in.close(); //Închiderea dosarului

/* Citim primul rând caracter cu caracter și îl afișăm pe ecran */

pentru (i =0 ;a !=*“” ;i++)
{
dacă (i >dimensiunea(a)) pauză ;
cout<
}
cout<<“\n” ; \\ A mutat cursorul pe o linie nouă

/* Citim a doua linie caracter cu caracter și o afișăm pe ecran */

pentru (i =0 ;b !=*“” ;i ++)
{
dacă (i > dimensiunea (b)) pauză ;
cout<
}
cout<<“\n” ; \\ A mutat cursorul pe o linie nouă

/* Citim a treia linie caracter cu caracter și o afișăm pe ecran */

pentru (i =0 ;с !=*“” ;i++)
{
dacă (i>dimensiunea (c)) pauză ;
cout<<с[i];
}

getch(); \\Se așteaptă apăsarea tastei Enter
returnează 0;
}
===================

Acest material descrie un exemplu de citire a informațiilor personaj cu caracter. Din moment ce nu am descris lucrul cu variabile precum char, atunci începătorii pot întâmpina unele inconveniente în înțelegerea codului. Doar că nu știam ce tip char are unele particularități și credeam că totul era mai simplu. Prin urmare, câteva momente de neînțeles ale programului de mai sus pot fi citite în articolul următor lucrul cu char V C++ pentru începători

În caz contrar, exemplul dat despre cum să citești linii dintr-un fișier text în C++ ar trebui să fie accesibil și destul de ușor de înțeles. Aceasta nu este opțiunea optimă de implementare în acest moment și am omis câteva puncte importante, dar din moment ce începem să învățăm limbajul C++, acest lucru este suficient deocamdată. Mai târziu voi ajunge probabil la ceea ce mi-a ratat, dar acum trebuie să percep doar ceea ce este necesar.

Dacă tu și cu mine înțelegem acest material, înseamnă că am făcut un mic pas spre profesionalismul nostru.

Notă:
pauză ;– Aceasta este comanda care iese din buclă. Avem dacă contorul de cicluri pentru devine mai mare decât dimensiunea declarată a variabilei char, apoi ieșim forțat din buclă
!= – Aceasta este condiția pe care o punem. Această condiție este indicată de inegalitate
dacă (a !=b)– Citește ca și cum A nu este egal b

endl ; – Aceasta este pentru a muta cursorul pe o nouă linie în interiorul consolei (din câte am înțeles)
Această comandă este similară cu „\n”

– comparație pentru a identifica egalitatea sau inegalitatea.

Scopul practic al unei enumerări este de a defini un set de constante simbolice distincte de tip întreg.

Un exemplu de utilizare a variabilelor enumerate:

mo=1, tu, we, th, fr, sa, su ) zile;

puts(“ Introduceți ziua săptămânii (de la 1 la 7) : ”); scanf(„%d”, &t_zi);

w_day = su; start = lună;

sfârşit = w_day -t_day;

printf(„\nLuni este %d zi a săptămânii, \acum este %d zi.\n\

Până la sfârșitul săptămânii %d zile (zile). ”, start, t_day, end);

Rezultatul programului: Introduceți ziua săptămânii (de la 1 la 7): 2

Luni este prima zi a săptămânii, acum este a 2-a zi. Mai sunt 5 zile (zile) până la sfârșitul săptămânii.

18. Fișiere în limbaj C

Un fișier este un set de date situat pe medii externe și luate în considerare în timpul procesării ca un întreg. Fișierele conțin date destinate stocării pe termen lung.

Există două tipuri de fișiere: text și binare. Fișierele text sunt o secvență de caractere ASCII și pot fi vizualizate și editate folosind orice editor de text.

Fișierele binare (binare) sunt o secvență de date, a căror structură este determinată de software.

Limbajul C are un set mare de funcții pentru lucrul cu fișiere, dintre care majoritatea se găsesc în bibliotecile stdio.h și io.h.

18.1. Deschiderea unui fișier

Fiecărui fișier i se atribuie un nume logic intern, care este folosit ulterior la accesarea acestuia. Numele logic (identificatorul fișierului) este

pointer către fișier, adică într-o zonă de memorie care conține toate informațiile necesare despre fișier. Formatul de declarare a indicatorului de fișier este următorul:

	FIȘIER * pointer către fișier;
FILE – identificatorul tipului de structură descris în biblioteca standard
stdio.h și care conține următoarele informații:
tip struct(
	– numărul de octeți necitiți rămași în buffer;
	dimensiunea obișnuită a memoriei tampon este de 512 octeți; de îndată ce nivelul=0,
	următorul bloc de date este citit în buffer din fișier;
	– steag de stare a fișierului – citiți, scrieți, adăugați;
	– descriptor de fișier, adică număr care definește numărul său
păstrare caracter nesemnat;	– caracter netransmis, i.e. ungetc-caracter;
	– dimensiunea tamponului intermediar intern;
buffer de caracter nesemnat;	– valoarea pointerului pentru accesul în interiorul bufferului, adică
	specifică începutul bufferului, începutul liniei sau valoarea curentă
	Valoarea pointerului din interiorul bufferului depinde de mod
	ma tamponare;
caracter nesemnat *curp;	– valoarea curentă a pointerului pentru acces în interiorul
	fera, adică specifică poziția curentă în tamponul de schimb
	mai departe cu programul;
istemp nesemnat;	– flag de fișier temporar;
	– marcați când lucrați cu un fișier;
) DOSAR;

Înainte de a începe să lucrați cu fișierul, de ex. Pentru a putea citi sau scrie informații într-un fișier, acesta trebuie să fie deschis pentru acces. În acest scop, funcția este de obicei utilizată

FILE* fopen(char* nume_fișier, mod char*);

este nevoie de o reprezentare externă - numele fizic al unui fișier pe un mediu (dischetă, hard disk) și îl potrivește cu un nume logic.

Numele fizic, adică numele fișierului și calea către acesta sunt specificate de primul parametru

– o linie, de exemplu, „a:Mas_dat.dat” – un fișier numit Mas_dat.dat situat pe o dischetă, „d:\\work\\Sved.txt” – un fișier denumit Sved.txt situat pe hard drive în directorul de lucru.

Atenţie! Bara oblică inversă (\), ca caracter special, este scrisă de două ori într-o linie.

La deschiderea cu succes, funcția fopen returnează un pointer către fișier (denumit în continuare indicatorul fișierului). În caz de eroare, este returnat NULL. Această situație apare de obicei atunci când calea către fișierul care urmează să fie deschis este specificată incorect. De exemplu, dacă în clasa de afișare a universității noastre specificați o cale care este interzisă pentru scriere (de obicei d:\work\ este permisă).

Al doilea parametru este o linie care specifică modul de acces la fișier:

w – dosarul este deschis pentru scriere; dacă nu există niciun fișier cu numele dat, acesta va fi creat; dacă un astfel de fișier există, atunci informațiile anterioare sunt distruse înainte de deschidere;

r – fișierul se deschide doar pentru citire; dacă nu există un astfel de fișier, apare o eroare;

a – fișierul este deschis pentru a adăuga informații noi până la sfârșit;

r+ – fișierul este deschis pentru editarea datelor – este posibilă atât scrierea, cât și citirea informațiilor;

w+ – la fel ca pentru r+;

a+ – la fel ca și pentru a, doar scrierea se poate face oriunde în fișier; citirea fișierelor este, de asemenea, disponibilă;

t – fișierul se deschide în modul text b – fișierul se deschide în modul binar;

Modul text diferă de modul binar prin faptul că, atunci când un fișier este deschis ca text, perechea de caractere „line feed”, „carriage return” este înlocuită cu un singur caracter: „line feed” pentru toate funcțiile de scriere a datelor în fișier , iar pentru toate funcțiile de ieșire, caracterul „line feed” „ este acum înlocuit cu două caractere: „line feed”, „carriage return”.

În mod implicit, fișierul se deschide în modul text. Exemplu: FILE *f; – este declarat un pointer către fișierul f;

f = fopen("d:\\work\\Dat_sp.cpp", "w"); – se deschide spre scriere un fișier cu numele logic f, care are denumirea fizică Dat_sp.cpp, aflat pe unitatea d, în directorul de lucru; sau mai pe scurt

FIȘIER *f = fopen("d:\\work\\Dat_sp.cpp", "w");

18.2. Închiderea unui fișier

După ce lucrați cu un fișier, accesul la acesta trebuie închis. Acest lucru este realizat de funcția int fclose (pointer fișier). De exemplu, din exemplul anterior, fișierul este închis astfel: fclose (f);

Pentru a închide mai multe fișiere, se introduce o funcție, declarată astfel: void fcloseall (void);

Dacă trebuie să schimbați modul de acces pentru un fișier, trebuie mai întâi să închideți fișierul și apoi să îl deschideți din nou, dar cu drepturi de acces diferite. Pentru a face acest lucru, utilizați funcția standard:

FILE* freeopen (char*file_name, char *mode, FILE *file_pointer);

Această funcție închide mai întâi fișierul declarat file_pointer(cum face funcția fopen), apoi deschide fișierul cu numele fișierului și permisiunile „mod”.

Limbajul C are capacitatea de a lucra cu fișiere temporare care sunt necesare doar în timp ce programul rulează. În acest caz se utilizează funcția

FILE* tmpfile(void);

care creează un fișier temporar pe disc cu drepturi de acces „w+b” după finalizarea programului sau după închiderea fișierului temporar, acesta este șters automat;

18.3. Scrie – citește informații

Toate acțiunile de citire și scriere a datelor într-un fișier pot fi împărțite în trei grupuri: operații de intrare-ieșire caracter cu caracter; operațiuni I/O linie cu linie; blocarea operațiunilor I/O.

Să ne uităm la principalele funcții utilizate în fiecare dintre aceste trei grupuri de operații.

I/O caracter cu caracter

În funcțiile I/O caracter cu caracter, un caracter este primit dintr-un fișier sau un caracter este trimis către un fișier:

I/O rând

Funcțiile de intrare/ieșire de linie se transferă dintr-un fișier sau către

Bloc I/O

Funcțiile bloc I/O operează pe blocuri întregi

informație:
int fread (void*p, intsize,	– citește n blocuri de dimensiunea octeților fiecare din fișier
int n, FIȘIER *f)	la f către o zonă de memorie cu indicatorul p (obligatoriu
int fwrite (void*p, intsize,	alocați memorie în avans pentru blocul de citit);
	– scrie n blocuri de octeți de dimensiune fiecare din
int n, FIȘIER *f)	zonă de memorie cu indicatorul p către fișierul f.

I/O formatat este produs de funcții.