/* 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”

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ă, 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 la linie, Număr de caractere, flux);

Caracterele sunt citite din flux până când este citit un caracter newline „\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, măriți-l cu 3 și salvați-l în fișierul s2.txt.

Lucrul cu fișiere text în C++.

Există două tipuri principale de fișiere: text și binare. Fișierele permit utilizatorului să citească cantități mari de date direct de pe disc, fără a fi nevoie să le introducă de la tastatură.

Text sunt apelate fișiere formate din orice caractere. Ele sunt organizate în rânduri, fiecare se termină cu un caracter de final de linie. Sfârșitul fișierului în sine este indicat de simbolul „sfârșitul fișierului”. Când scrieți informații într-un fișier text, care poate fi vizualizat folosind orice editor de text, toate datele sunt convertite într-un tip de caracter și stocate sub formă de caractere.

ÎN binarÎn fișiere, informațiile sunt citite și scrise sub formă de blocuri de o anumită dimensiune, în care pot fi stocate date de orice tip și structură.

Pentru a lucra cu fișiere, special tipuri de date, numit cursuri. curgere ifstream este folosit pentru a lucra cu fișiere în modul de citire și ofstreamîn modul înregistrare. Pentru a lucra cu fișiere atât în ​​modul de scriere, cât și în modul de citire, se folosește un flux fstream.

În programele C++, atunci când lucrați cu fișiere text, trebuie să includeți bibliotecile iostream și fstream.

Pentru a scrie date într-un fișier text, aveți nevoie de:

descrie o variabilă de tip de flux.

scoateți informații într-un fișier.

asigurați-vă că închideți fișierul.

Pentru citind date dintr-un fișier text, aveți nevoie de:

descrie o variabilă de tip ifstream.

deschideți un fișier folosind funcția de deschidere.

închideți fișierul.

Record informații într-un fișier text

După cum am menționat mai devreme, pentru a începe să lucrați cu un fișier text, trebuie să definiți o variabilă de tip de flux. De exemplu, așa:

O variabilă F va fi creată pentru a scrie informații în fișier.

În etapa următoare, fișierul trebuie deschis pentru scriere. În general, operatorul de deschidere a fluxului va arăta astfel:

F.open(„fișier”, mod);

Aici F este o variabilă descrisă ca ofstream,

fișier - numele complet al fișierului de pe disc,

mod - modul de lucru cu fișierul deschis.

Vă rugăm să rețineți că atunci când specificați numele complet al fișierului, trebuie să utilizați o bară oblică dublă. De exemplu, numele complet al fișierului noobs.txt, aflat în folderul jocului de pe unitatea D:, va trebui scris astfel:

D:\\joc\\noobs.txt.

Fișierul poate fi deschis în unul dintre următoarele moduri:

ios::in - deschideți fișierul în modul de citire a datelor, acest mod este modul implicit pentru ifstreams;

ios::out - deschideți un fișier în modul de scriere a datelor (în acest caz, informațiile despre fișierul existent sunt distruse), acest mod este modul implicit pentru ofstreams;

ios::app - deschideți fișierul în modul de scriere a datelor până la sfârșitul fișierului;

ios::ate - trece la sfârșitul unui fișier deja deschis;

ios::trunc - șterge fișierul, asta se întâmplă și în modul ios::out;

ios::nocreate - nu deschideți un fișier dacă acesta nu există;

ios::noreplace - nu deschideți un fișier existent.

Parametrul mode poate fi absent, caz în care fișierul este deschis în modul implicit pentru acest flux.

După deschiderea cu succes a fișierului (în orice mod), variabila F va stoca true, altfel false. Acest lucru vă va permite să verificați corectitudinea operațiunii de deschidere a fișierului.

Puteți deschide un fișier (să luăm ca exemplu fișierul D:\\game\\noobs.txt) în modul înregistrare în unul dintre următoarele moduri:

// primul cale

din fluxul F;

F.open("D:\\game\\noobs.txt", ios::out);

//a doua metodă, modul ios::out este modul implicit

// Pentru curgereofstream

din fluxul F;

//a treia metodă combină descrierea variabilei și tipul fluxului

//și deschiderea fișierului într-o singură instrucțiune

ofstream F("D:\\game\\noobs.txt", ios::out);

După deschiderea fișierului în modul de scriere, va fi creat un fișier gol în care puteți scrie informații.

Dacă doriți să deschideți un fișier existent în modul scris înainte, modul ar trebui să fie ios::app.

După deschiderea unui fișier în modul de înregistrare, puteți scrie în el în același mod ca pe ecran, doar în locul dispozitivului de ieșire standardcouttrebuie să specificați numele fișierului deschis.

De exemplu, pentru a scrie variabila a în fluxul F, instrucțiunea de ieșire va arăta astfel:

Pentru ieșirea secvențială în fluxul G de variabile b, c, d, operatorul de ieșire va deveni astfel:

G<

Închiderea unui flux se face folosind operatorul:

EXEMPLU:

Creați un fișier text D:\\game\\noobs.txt și scrieți n numere reale în el.

#include „stdafx.h”

#include

#include

#include

folosind namespace std;

int main()

setlocale(LC_ALL, "RUS");

int i, n;

dublu a;

//descrie un flux pentru scrierea datelor într-un fișier

ofstream f;

//deschideți fișierul în modul de scriere,

//modulios:: afarăinstalat implicit

f.open("D:\\game\\noobs.txt", ios::out);

//introduceți numărul de numere reale

cout<<" n="; cin>> n;

//buclă pentru introducerea numerelor reale

//și scrieți-le într-un fișier

pentru (i=0; i

cout<<"a=";

//introduceți un număr

cin>>a;

f<

//închiderea fluxului

f.close();

sistem(„pauză”);

returnează 0;

_______________________________________________________________

Pentru a citi informații dintr-un fișier text, trebuie să descrii o variabilă precum ifstream. După aceasta, trebuie să deschideți fișierul pentru citire folosind operatorul deschis. Dacă variabila se numește F, atunci primele două afirmații vor fi astfel:

F.open("D:\\joc\\noobs.txt", ios::in);

După deschiderea unui fișier în modul de citire, puteți citi informațiile din acesta în același mod ca și de la tastatură, doar în loc decinspecificați numele fluxului din care vor fi citite datele.

De exemplu, pentru a citi din fluxul F în variabila a, instrucțiunea de intrare ar arăta astfel:

Două numere dintr-un editor de text sunt considerate separate dacă există cel puțin unul dintre caracterele între ele: spațiu, tab, sfârșit de rând. Este bine dacă programatorul știe dinainte câte și ce valori să stocheze în fișierul text. Cu toate acestea, adesea tipul de valori stocate în fișier este pur și simplu cunoscut, dar numărul acestora poate varia. Pentru a rezolva această problemă, trebuie să citiți valorile din fișier pe rând și, înainte de fiecare citire, verificați dacă s-a ajuns la sfârșitul fișierului. Există o funcție pentru asta F. eof().

Aici F este numele firului de execuție, funcția returnează o valoare booleană: adevărat sau fals, în funcție de sfârșitul fișierului. Prin urmare, o buclă pentru a citi conținutul întregului fișier poate fi scrisă astfel:

//organizare pentru citirea valorilor dintr-un fișier, execuție

//bucla se va rupe când ajungem la sfârșitul fișierului,

//în acest caz F.eof() va returna adevărat

în timp ce (!F.eof())

EXEMPLU:

Fișierul text D:\\game\\noobs.txt stochează numere reale, le afișează pe ecran și le calculează numărul.

#include „stdafx.h”

#include

#include

#include

#include

folosind namespace std;

int main()

setlocale(LC_ALL, "RUS");

int n=0;

plutire a;

fstream F;

//deschideți fișierul în modul de citire

F.open("D:\\joc\\noobs.txt");

//dacă fișierul a fost deschis corect, atunci

//buclă pentru citirea valorilor dintr-un fișier; execuția buclei va fi întreruptă,

// când ajungem la sfârșitul fișierului, în acest caz F.eof() va returna true.

în timp ce (!F.eof())

//citirea următoarei valori din fluxul F în variabila a

F>>a;

//trimite valoarea variabilei a pe ecran

cout<

//crește numărul de numere citite

//închiderea fluxului

F.close();

//introduceți pe ecran numărul de numere citite

cout<<"n="<

//dacă deschiderea fișierului a fost incorectă, atunci rezultatul

//mesaje despre absența unui astfel de fișier

altfel cout<<" Файл не существует"<

sistem(„pauză”);

returnează 0;

C++. Procesarea fișierelor binare

Când scrieți informații într-un fișier binar, caracterele și numerele sunt scrise ca o secvență de octeți.

Pentru a scrie date într-un fișier binar, aveți nevoie de:

descrieți o variabilă de fișier de tip FAIL * folosind operatorul FILE *filename; Aici filename este numele variabilei în care va fi stocat indicatorul către fișier.

scrieți informații într-un fișier folosind funcția fwrite

Pentru a considera b date dintr-un fișier binar, trebuie să:

descrie o variabilă de tip FILE *

deschideți un fișier folosind funcția fopen

închideți un fișier folosind funcția fclose

Funcții de bază necesare pentru a lucra cu fișiere binare.

Pentru descoperiri Fișierul este destinat funcției fopen.

FILE *fopen(const *nume fișier, const char *mod)

Aici filename este un șir care stochează numele complet al fișierului deschis, mode este un șir care determină modul de lucru cu fișierul; sunt posibile următoarele valori:

„rb” - deschideți fișierul binar în modul de citire;

„wb” - creați un fișier binar pentru înregistrare; dacă există, conținutul său este șters;

„ab” - creați sau deschideți un fișier binar pentru a adăuga la sfârșitul fișierului;

„rb+” - deschideți un fișier binar existent în modul citire-scriere;

„wb+” - deschideți fișierul binar în modul citire-scriere, fișierul existent este șters;

„ab+” - un fișier binar este deschis sau creat pentru a corecta informațiile existente și pentru a adăuga informații noi la sfârșitul fișierului.

Funcția returnează valoarea NULL în variabila fișier f dacă deschiderea fișierului eșuează. După deschiderea unui fișier, al 0-lea octet al acestuia este disponibil, indicatorul fișierului este 0, a cărui valoare, pe măsură ce este citit sau scris, este deplasată cu numărul de octeți citiți (scriși). Valoarea curentă a indicatorului de fișier este numărul de octeți de la care va avea loc operația de citire sau scriere.

Pentru închidere fișierul este destinat funcției fclose

int fclose(FIȘIER *nume fișier);

Returnează 0 dacă fișierul a fost închis cu succes, NULL în caz contrar.

Funcția de eliminare este pentru îndepărtare fişiere.

int remove(const char *nume fișier);

Această funcție șterge de pe disc un fișier numit fileenema. Fișierul de șters trebuie să fie închis. Funcția returnează o valoare diferită de zero dacă fișierul nu a putut fi șters.

Pentru redenumire fișiere, funcția de redenumire este destinată:

int rename(const char *oldfilename, const char *newfilename);

Primul parametru este numele vechiului fișier, al doilea este cel nou. Returnează 0 dacă programul se încheie cu succes.

Citind dintr-un fișier binar se face folosind funcția fread:

fread(void *ptr, size, n, FILE *filename);

Funcția fread citește n elemente cu dimensiunea dimensiunii din numele fișierului într-o matrice ptr. Funcția returnează numărul de elemente citite. După citirea dintr-un fișier, indicatorul acestuia este deplasat cu n*size octeți.

Record la un fișier binar se face folosind funcția fwrite:

fwrite(const void *ptr, size, n, FILE *filename);

Funcția fwrite scrie în fișier nume de fișier dintr-o matrice ptr de n elemente cu dimensiunea mărimii. Funcția returnează numărul de elemente scrise. După scrierea informațiilor în fișier, indicatorul este deplasat cu n*size octeți.

Pentru control la sfârșitul fișierului există o funcție de:

int feof(FIȘIER *nume fișier);

Returnează o valoare diferită de zero dacă se ajunge la sfârșitul fișierului.

EXEMPLU:

Creați un fișier binar D:\\game\\noobs.dat și scrieți n numere întregi și n numere reale în el.

#include „stdafx.h”

#include

folosind namespace std;

int main()

setlocale(LC_ALL, "RUS");

int n, i;

dublu a;

//creăm un fișier binar în modul de scriere

f=fopen("D:\\game\\noobs.dat", "wb");

// intrare numeren

cout<<"n="; cin>>n;

fwrite(&n, sizeof(int), 1, f);

//buclă pentru a introduce n numere reale

pentru (i=0; i

//introduceți următorul număr real

cout<<"a=";

cin>>a;

//scrierea unui număr real într-un fișier binar

fwrite(&a, sizeof(double), 1, f);

// închide fişier

fclose(f);

sistem(„pauză”);

returnează 0;

EXEMPLU:

Afișați conținutul fișierului binar D:\\game\\noobs.dat creat în sarcina anterioară

#include „stdafx.h”

#include

folosind namespace std;

int main()

setlocale(LC_ALL, "RUS");

int n, i;

dublu *a;

DOSAR *f; //descrieți variabila fișier

//deschideți fișierul binar existent în modul citire

//citește un număr întreg din fișier în variabila n

//ieșire n pe ecran

cout<<"n="<

//alocarea memoriei pentru o matrice de n numere

a=dublu nou[n];

//citește n numere reale din fișier în tabloul a

//Ieșiți matricea pe ecran

pentru (i=0; i

cout<

cout<

// închide fişier

fclose(f);

sistem(„pauză”);

returnează 0;

Fisier binar- structura secventiala a datelor, dupa deschiderea unui fisier, primul octet stocat in acesta este disponibil. Puteți scrie sau citi date dintr-un fișier secvenţial. Să presupunem că trebuie să numărați al cincisprezecelea număr și apoi primul. Folosind accesul secvenţial, acest lucru se poate face în felul următor:

int n, i;

dublu a;

DOSAR *f;

f=fopen("D:\\game\\noobs.dat", "rb");

pentru (i=0; i<15; i++)

fclose(f);

f=fopen("D:\\game\\noobs.dat", "rb");

fread(&a, sizeof(double), 1, f);

fclose(f);

După cum puteți vedea, citirea numerelor dintr-un fișier și apoi deschiderea din nou a fișierului nu este cea mai convenabilă modalitate. Va fi mult mai convenabil să folosiți funcția fseek pentru a muta indicatorul fișierului pe un octet dat.

int fseek(FIȘIER *nume fișier, offset int lung, origine int);

Funcția setează indicatorul de poziție a fișierului curent F în conformitate cu valorile de origine și offset. Parametrul offset este egal cu numărul de octeți cu care indicatorul fișierului va fi decalat în raport cu originea specificată de parametrul origine. Valoarea parametrului de origine trebuie să fie una dintre următoarele valori de offset definite în antetul stdio.h:

SEEK_SET - de la începutul fișierului;

SEEK_CUR - din pozitia curenta;

SEEK_END - de la sfârșitul fișierului.

Funcția returnează o valoare zero dacă operația a avut succes, diferită de zero dacă a avut loc un eșec în timpul execuției offsetului

Funcția fseek implementează de fapt accesul direct la orice valoare dintr-un fișier. Trebuie doar să știți locația (numărul de octeți) a valorii din fișier. Să ne uităm la utilizarea accesului direct în fișierele binare folosind următoarea problemă ca exemplu.

EXEMPLU

În fișierul binar D:\\game\\noobs.dat creat mai devreme, schimbați cele mai mari și cele mai mici numere reale.

Algoritmul de rezolvare a problemei constă din următoarele etape:

citirea reale dintr-un fișier în matrice a.

căutați în tabloul a valorile maxime (max) și minime (min) și numerele acestora (imax, imin).

mutarea indicatorului de fișier la valoarea maximă și scrierea min.

mutarea indicatorului de fișier la valoarea minimă și scrierea max.

Mai jos este textul programului pentru rezolvarea problemei cu comentarii.

#include „stdafx.h”

#include

folosind namespace std;

int main()

setlocale(LC_ALL, "RUS");

int n, i, imax, imin;

dublu *a, max, min;

DOSAR *f;

//deschide un fișier în modul citire-scriere

f=fopen("D:\\game\\noobs.dat", "rb+");

//citește numărul din fișier în variabila n

//numerele reale din fișier

fread(&n, sizeof(int), 1, f);

cout<<"n="<

//aloca memorie pentru stocarea numerelor reale,

//care va fi stocat în tabloul a

a=dublu nou[n];

//citește din fișier în matrice și numere reale

fread(a, sizeof(double), n, f);

//căutați elemente maxime și minime

//în tabloul a și indicii acestora

pentru (imax=imin=0, max=min=a, i=1; i

dacă (a[i]>max)

max=a[i];

dacă (a[i]

min=a[i];

// in miscare indicator La maxim element

fseek(f, sizeof(int)+imax*sizeof(double), SEEK_SET);

// scrie elementul minim în loc de maxim

fwrite(&min, sizeof(double), 1, f);

// in miscare indicator La minim element

fseek(f, sizeof(int)+imin*sizeof(double), SEEK_SET);

// scrie max în loc de elementul de fișier minim

fwrite(&max, sizeof(double), 1, f);

//închiderea fișierului

fclose(f);

//memorie libera

șterge [ ]A;

sistem(„pauză”);