Puna programuese me skedarë teksti. Puna me skedarë teksti

Për një programues skedar i hapur përfaqësohet si një sekuencë e të dhënave që lexohen ose shkruhen. Kur hapet një skedar, ai lidhet me I/O rrymë ... Informacioni dalës shkruhet në rrjedhë, informacioni hyrës lexohet nga transmetimi.

Kur hapet një transmetim për I/O, ai lidhet me një strukturë standarde të tipit FILE, e cila përcaktohet në stdio.h. Struktura FILE përmban informacionin e nevojshëm në lidhje me dosjen.

Skedari hapet duke përdorur funksionin fopen (), i cili kthen një tregues në një strukturë FILE, e cila mund të përdoret për operacionet e mëvonshme me skedarin.

FILE * fopen (emri, lloji);

emri - emri i skedarit që do të hapet (përfshirë shtegun),
lloji është një tregues për një varg karakteresh që përcaktojnë se si të aksesoni skedarin:

· "R" - hapni një skedar për lexim (skedari duhet të ekzistojë);

· "W" - i hapur skedar bosh për regjistrim; nëse skedari ekziston, atëherë përmbajtja e tij humbet;

· "A" - hapni skedarin për shkrim deri në fund (për shtim); skedari krijohet nëse nuk ekziston;

· "R +" - hapni një skedar për lexim dhe shkrim (skedari duhet të ekzistojë);

· "W +" - hap një skedar bosh për lexim dhe shkrim; nëse skedari ekziston, atëherë përmbajtja e tij humbet;

· "A +" - hapni skedarin për lexim dhe shtim, nëse skedari nuk ekziston, atëherë ai krijohet.

Vlera e kthyer është një tregues për rrjedhën e hapur. Nëse haset një gabim, kthehet NULL.

Funksioni fclose () mbyll transmetimin ose transmetimet që lidhen me skedarët e hapur me fopen (). Rrjedha për mbyllje përcaktohet nga argumenti i funksionit fclose ().

Vlera e kthyer: vlera 0, nëse transmetimi u mbyll me sukses; EOF konstante nëse ka ndodhur një gabim.

#përfshi
int main ()

emri char = "my.txt";

nëse (fp = fopen (emri, "r")! = NULL)

// a ishte e mundur hapja e skedarit?
... // veprimet e nevojshme mbi të dhënat

else printf ("Dështoi në hapjen e skedarit");

Leximi i një karakteri nga një skedar:

char fgetc (lumë);

Argumenti i funksionit është një tregues drejt një rryme të tipit FILE. Funksioni kthen kodin e karakterit të lexuar. Nëse arrihet fundi i skedarit ose ndodh një gabim, EOF konstante kthehet.
Shkrimi i një karakteri në një skedar:

fputc (personazh, rrymë);

Argumentet e funksionit janë një karakter dhe një tregues drejt një rryme të tipit FILE. Funksioni kthen kodin e karakterit të lexuar.

Funksionet Fscanf () dhe fprintf () janë të ngjashme funksionet e skanimit() dhe printf (), por punoni me skedarë të dhënash dhe keni argumentin e parë, një tregues skedari.

fscanf (stream, "Input Format", argumente);
fprintf (stream, "Output Format", argumente);

Funksionet fgets () dhe fputs () janë të destinuara për hyrje / dalje të vargjeve; ato janë analoge me funksionet gets () dhe puts () për të punuar me skedarë.

fgets (Pointer Per Line, Number of Characters, stream);

Personazhet lexohen nga transmetimi derisa të lexohet një personazh linjë e re"\ n", i cili përfshihet në varg, ose deri në fund të transmetimit EOF ose është lexuar numri maksimal i karaktereve. Rezultati vendoset në një tregues në një varg dhe përfundon me një karakter null "\ 0". Funksioni kthen adresën e vargut.

fputs (Pointer To String, stream);

Kopjon një varg në transmetim nga pozicioni aktual. Karakteri null përfundues nuk kopjohet.
Shembull Futni numrin dhe ruajeni në skedarin s1.txt. Lexoni numrin nga skedari s1.txt, rriteni me 3 dhe ruajeni në skedarin s2.txt.

Fopen () hap një transmetim për përdorim, lidh një skedar me transmetimin e dhënë dhe më pas kthen një tregues FILE në rrymë e dhënë... Më shpesh sesa jo, një skedar shihet si skedari i diskut... Funksioni fopen () ka prototipin e mëposhtëm:

FILE * fopen (const char * emri i skedarit, const char * modaliteti);

Ku modaliteti tregon një varg që përmban modalitetin e dëshiruar për hapjen e skedarit. Vlerat e vlefshme për modalitetin në Borland C ++ tregohen në tabelë. emri i skedarit duhet të jetë një varg karakteresh që siguron një emër skedari të vlefshëm sistemi operativ, dhe mund të përmbajë një tregues shtegu.

Funksioni Fopen () kthen një tregues lloji i bazës DOSJE. Ky tregues identifikon skedarin dhe përdoret nga shumica e funksioneve. sistemi i skedarëve... Asnjëherë nuk duhet ta ndryshoni atë vetë. Funksioni kthen një tregues null nëse skedari nuk mund të hapet.

Siç tregon tabela, skedari mund të hapet në modalitetin tekst ose binar. Në modalitetin e tekstit, kur shkruani, sekuenca e kthimit dhe furnizimit të linjës përkthehet në një karakter të linjës së re. Në dalje, e kundërta është e vërtetë: karakteri i linjës së re përkthehet në kthimin e transportit dhe furnizimin e linjës. V binare nuk bëhet një përkthim i tillë. Kur as t dhe as b nuk specifikohen në argumentin e modalitetit, statusi i skedarit tekst/binar përcaktohet nga vlera e ndryshores globale _fmode të përcaktuar në Borland C ++. Si parazgjedhje, fmode është vendosur në O_TEXT, domethënë është vendosur modaliteti i tekstit... Nëse vendosni _fmode në O_BINARY, skedarët do të hapen në modalitetin binar. (Këto makro përcaktohen në fcntl.h.) Natyrisht, përdorimi i një t ose b të qartë heq efektet që lidhen me variablin _fmode. Gjithashtu, _fmode është specifike për produktet Borland. Nuk është përcaktuar në ANSI C I / O.

Nëse ju duhet të hapni një skedar të quajtur test për shkrim, duhet të shkruani:

Fp = fopen ("test", "w");

Ku fp është një ndryshore e tipit FILE *. Sidoqoftë, zakonisht mund të shihni sa vijon:

Nëse ((fp = fopen ("test", "w")) == NULL) (
vendos ("Nuk mund të hapet skedari.");
dalje (1);
}

Kjo metodë ju lejon të zbuloni gabime kur hapni një skedar, për shembull, prania e mbrojtjes nga shkrimi ose mungesa e tij hapesire e lire në disk.

Nëse fopen () përdoret për të hapur një skedar për shkrim, atëherë çdo skedar para-ekzistues me emri i specifikuar do të fshihet. Nëse një skedar me emrin e specifikuar nuk ekziston, atëherë ai do të krijohet.

Nëse keni nevojë të shtoni informacion në fund të skedarit, duhet të përdorni modalitetin a (shtoj). Nëse skedari nuk ekziston, atëherë ai do të krijohet.

Hapja e një skedari për lexim kërkon që skedari të ekzistojë. Nëse skedari nuk ekziston, atëherë do të kthehet një gabim. Nëse skedari është i hapur për funksionimin e leximit / shkrimit, atëherë ai nuk fshihet nëse është i pranishëm, dhe nëse skedari nuk ekziston, atëherë ai krijohet.

Puna me skedarë teksti në C ++.

Ekzistojnë dy lloje kryesore të skedarëve: tekst dhe binar. Skedarët lejojnë përdoruesin të lexojë sasi të mëdha të dhënash drejtpërdrejt nga disku pa e shtypur atë nga tastiera.

Teksti thirren skedarët që përbëhen nga ndonjë karakter. Ato janë të organizuara në rreshta, secila prej të cilave përfundon me një karakter fundor. Fundi i vetë skedarit tregohet me simbolin "fundi i skedarit". Kur shkruani informacion në një skedar teksti, i cili mund të shikohet duke përdorur çdo redaktues teksti, të gjitha të dhënat konvertohen në një lloj karakteri dhe ruhen në formën e karaktereve.

V binare skedarët, informacioni lexohet dhe shkruhet në formën e blloqeve të një madhësie të caktuar, në të cilat mund të ruhen të dhëna të çdo lloji dhe strukture.

Për të punuar me skedarë, të veçantë llojet e të dhënave thirrur përrenjtë... Rrjedha ifstream shërben për të punuar me skedarë në modalitetin e leximit dhe të rrjedhës në modalitetin e regjistrimit. Për të punuar me skedarë në modalitetin e shkrimit dhe të leximit, përdorni transmetimin fstream.

Në programet C ++, kur punoni me skedarë teksti, duhet të përfshini bibliotekat iostream dhe fstream.

Në mënyrë që shkruani të dhënat në një skedar teksti, duhet:

përshkruani një variabël të llojit të rrjedhës.

nxirrni informacionin në një skedar.

sigurohuni që ta mbyllni skedarin.

Për lexime të dhënat nga një skedar teksti, duhet:

përshkruani një variabël të tipit ifstream.

hapni skedarin duke përdorur funksionin e hapur.

mbyll skedarin.

Regjistrimi informacion në një skedar teksti

Siç u përmend më herët, për të filluar punën me skedar teksti, është e nevojshme të përshkruhet variabël si të rrjedhës. Për shembull, si kjo:

Një variabël F do të krijohet për të shkruar informacionin në skedar.

Hapi tjetër është hapja e skedarit për shkrim. V rast i përgjithshëm operatori i hapjes së transmetimit do të duket si ky:

F.hapur ("skedar", modaliteti);

Këtu F është një ndryshore, e përshkruar si rrjedhë,

skedar - emri i plotë skedar në disk,

modaliteti - mënyra e funksionimit me skedarin që hapet.

Ju lutemi vini re se duhet të përdorni një prerje të dyfishtë kur specifikoni emrin e plotë të skedarit. Për shembull, emri i plotë i skedarit noobs.txt i vendosur në dosjen e lojës në diskun D: duhet të shkruhet kështu:

D: \\ lojë \\ noobs.txt.

Skedari mund të hapet në një nga mënyrat e mëposhtme:

ios :: në - hapni një skedar në modalitetin e leximit të të dhënave, ky modalitet është modaliteti i paracaktuar për transmetimet ifstream;

ios :: jashtë - hapni një skedar në modalitetin e regjistrimit të të dhënave (informacioni për skedarin ekzistues shkatërrohet), ky modalitet është modaliteti i paracaktuar për transmetimet e rrjedhës;

ios :: app - hapni një skedar në mënyrën e shkrimit të të dhënave deri në fund të skedarit;

ios :: ate - lëvizni në fund të një skedari tashmë të hapur;

ios :: trunc - pastroni skedarin, e njëjta gjë ndodh në modalitetin ios :: jashtë;

ios :: nocreate - mos e hap skedarin nëse nuk ekziston;

ios :: noreplace - mos hap një skedar ekzistues.

Parametri i modalitetit mund të mungojë, në këtë rast skedari hapet në modalitetin e paracaktuar për këtë transmetim.

Pas hapjes me sukses të skedarit (në çdo modalitet), ndryshorja F do të ruajë true, përndryshe false. Kjo do të kontrollojë korrektësinë e operacionit të hapur të skedarit.

Mund ta hapni skedarin (merrni si shembull skedarin D: \\ game \\ noobs.txt) në modalitetin e regjistrimit në një nga mënyrat e mëposhtme:

// së pari mënyrë

rrjedha F;

F.open ("D: \\ lojë \\ noobs.txt", ios :: jashtë);

// mënyra e dytë, ios :: modaliteti i daljes është i paracaktuar

// për rrjedhintë rrjedhës

rrjedha F;

// mënyra e tretë kombinon përshkrimin e ndryshores dhe llojin e rrjedhës

// dhe hapni skedarin në një deklaratë

ofstream F ("D: \\ lojë \\ noobs.txt", ios :: jashtë);

Pas hapjes së skedarit në modalitetin e shkrimit, do të krijohet një skedar bosh, në të cilin do të jetë e mundur të shkruani informacion.

Nëse dëshironi të hapni një skedar ekzistues në modalitetin e parashkrimit, përdorni vlerën e aplikacionit ios :: si modalitet.

Pas hapjes së një skedari në modalitetin e shkrimit, mund t'i shkruani në të njëjtën mënyrë si në ekran, vetëm në vend të pajisjes standarde të daljescoutju duhet të specifikoni emrin e skedarit të hapur.

Për shembull, për të shkruar variablin a në transmetimin F, operatori i daljes do të duket kështu:

Për daljen sekuenciale në rrjedhën G të variablave b, c, d, operatori i daljes do të bëhet:

G<

Transmetimi mbyllet duke përdorur operatorin:

SHEMBULL:

Krijoni një skedar teksti D: \\ lojë \\ noobs.txt dhe shkruani n numra realë në të.

#include "stdafx.h"

#përfshi

#përfshi

#përfshi

duke përdorur hapësirën e emrave std;

int main ()

setlocale (LC_ALL, "RUS");

int i, n;

dyfishi a;

// përshkruan një rrymë për të shkruar të dhëna në një skedar

të rrjedhës f;

// hapni skedarin në modalitetin e shkrimit,

//modalitetiios:: jashtëinstaluar si parazgjedhje

f.open ("D: \\ lojë \\ noobs.txt", ios :: jashtë);

// shkruani numrin e numrave realë

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

// cikli për futjen e numrave realë

// dhe shkruajini ato në një skedar

për (i = 0; i

cout<<"a=";

// fut një numër

cin >> a;

f<

// mbyll rrymën

f.mbyll ();

sistemi ("pauzë");

kthimi 0;

_______________________________________________________________

Për të lexuar informacion nga një skedar teksti, duhet të deklaroni një variabël të llojit ifstream... Pas kësaj, duhet të hapni skedarin për lexim duke përdorur operatorin hapur... Nëse ndryshorja quhet F, atëherë dy operatorët e parë do të jenë si ky:

F.open ("D: \\ lojë \\ noobs.txt", ios :: në);

Pas hapjes së një skedari në modalitetin e leximit, mund të lexoni informacion prej tij në të njëjtën mënyrë si nga tastiera, vetëm në vend tëcinspecifikoni emrin e rrymës nga e cila do të lexohen të dhënat.

Për shembull, për të lexuar nga rrjedha F në ndryshoren a, deklarata hyrëse do të duket si kjo:

Dy numra në një redaktues teksti konsiderohen të ndarë nëse ka të paktën një nga karakteret midis tyre: hapësirë, tabelë, karakter në fund të rreshtit. Është mirë nëse programuesi e di paraprakisht se sa dhe çfarë vlerash ruhen në një skedar teksti. Sidoqoftë, lloji i vlerave të ruajtura në skedar shpesh dihet thjesht dhe numri i tyre mund të ndryshojë. Kur zgjidhni këtë problem, duhet të lexoni vlerat nga skedari një nga një dhe para çdo leximi, kontrolloni nëse është arritur fundi i skedarit. Për këtë ekziston një funksion F. eof().

Këtu F është emri i transmetimit. Funksioni kthen një vlerë boolean: true ose false, në varësi të faktit nëse është arritur fundi i skedarit. Prandaj, cikli për leximin e përmbajtjes së të gjithë skedarit mund të shkruhet si kjo:

// organizoni të lexoni vlerat nga një skedar, ekzekutoni

// cikli do të ndërpritet kur të arrijmë në fund të skedarit,

// në këtë rast F.eof () do të kthehet true

ndërsa (! F.eof ())

SHEMBULL:

Numrat realë ruhen në skedarin e tekstit D: \\ lojë \\ noobs.txt, shfaqini ato në ekran dhe llogaritni numrin e tyre.

#include "stdafx.h"

#përfshi

#përfshi

#përfshi

#përfshi

duke përdorur hapësirën e emrave std;

int main ()

setlocale (LC_ALL, "RUS");

int n = 0;

noton a;

fstream F;

// hapni skedarin në modalitetin e leximit

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

// nëse skedari është hapur saktë, atëherë

// lak për leximin e vlerave nga një skedar; ekzekutimi i ciklit do të ndërpritet,

// kur të arrijmë në fund të skedarit, në këtë rast F.eof () do të kthehet true.

ndërsa (! F.eof ())

// lexoni vlerën tjetër nga rrjedha F në variablin a

F >> a;

// shfaq vlerën e ndryshores a në ekran

cout<

// rrit numrin e numrave të lexuar

// mbyll rrymën

F.mbyll ();

// fut në ekran numrin e numrave të lexuar

cout<<"n="<

// nëse skedari është hapur gabimisht, atëherë dalja

// mesazhe për mungesën e një skedari të tillë

tjetër cout<<" Файл не существует"<

sistemi ("pauzë");

kthimi 0;

C ++. Trajtimi i skedarëve binare

Kur shkruani informacion në një skedar binar, karakteret dhe numrat shkruhen si një sekuencë bajtash.

Në mënyrë që shkruani të dhënat në një skedar binar, ju nevojiten:

përshkruani një variabël skedari të tipit FAIL * duke përdorur deklaratën FILE * emri i skedarit; Këtu emri i skedarit është emri i ndryshores ku do të ruhet treguesi i skedarit.

shkruani informacionin në skedar duke përdorur funksionin fwrite

Në mënyrë që lexoni b të dhëna nga një skedar binar, duhet:

përshkruani një variabël të tipit FILE *

skedari i hapur me funksionin fopen

mbyll skedarin duke përdorur funksionin fclose

Funksionet bazë të nevojshme për të punuar me binarët.

Për zbulimet skedari, funksioni hapet është menduar.

FILE * fopen (konst * emri i skedarit, modaliteti konst char *)

Këtu emri i skedarit është një varg që ruan emrin e plotë të skedarit për t'u hapur, mod është një varg që përcakton mënyrën e punës me skedarin; vlerat e mëposhtme janë të mundshme:

"Rb" - hapni një skedar binar në modalitetin e leximit;

"Wb" - krijoni një skedar binar për shkrim; nëse ekziston, atëherë përmbajtja e tij pastrohet;

"Ab" - krijoni ose hapni një skedar binar për ta shtuar në fund të skedarit;

"Rb +" - hapni një skedar binar ekzistues në modalitetin e leximit dhe shkrimit;

"Wb +" - hapni një skedar binar në modalitetin e leximit / shkrimit, skedari ekzistues pastrohet;

"Ab +" - hapet ose krijohet një skedar binar për të korrigjuar informacionin ekzistues dhe për të shtuar informacion të ri në fund të skedarit.

Funksioni kthen NULL në variablin e skedarit f nëse skedari nuk hapet me sukses. Pas hapjes së skedarit, është i disponueshëm bajt i 0-të i tij, treguesi i skedarit është i barabartë me 0, vlera e të cilit zhvendoset nga numri i bajteve të lexuara (shkruara) ndërsa lexohet ose shkruhet. Vlera aktuale e treguesit të skedarit është numri i bajtit, nga i cili fillon operacioni i leximit ose i shkrimit.

Për mbyllja skedari, funksioni fclose është menduar

int fclose (FILE * emri i skedarit);

Rikthen 0 në mbylljen e suksesshme të skedarit dhe NULL ndryshe.

Funksioni i heqjes është për duke fshirë dosjet.

int remove (const char * emri i skedarit);

Ky funksion heq një skedar të quajtur filenema nga disku. Skedari që do të fshihet duhet të mbyllet. Funksioni kthehet jozero nëse skedari nuk mund të fshihet.

Për riemërimi skedarët, funksioni i riemërtimit synohet:

int riemërto (const char * emri i vjetër i skedarit, const char * emri i ri i skedarit);

Parametri i parë është emri i skedarit të vjetër, i dyti është ai i ri. Kthen 0 pas suksesit.

Leximi nga një skedar binar bëhet duke përdorur funksionin fread:

fread (void * ptr, madhësia, n, FILE * emri i skedarit);

Funksioni fread lexon n elementë të madhësisë nga emri i skedarit në një grup ptr. Funksioni kthen numrin e artikujve të lexuar. Pas leximit nga skedari, treguesi i tij zhvendoset me n * bajtë me madhësi.

Regjistrimi në një skedar binar bëhet duke përdorur funksionin fwrite:

fwrite (konst void * ptr, madhësia, n, FILE * emri i skedarit);

Funksioni fwrite shkruan n elementë të madhësisë në emrin e skedarit nga grupi ptr. Funksioni kthen numrin e elementeve të shkruar. Pas shkrimit të informacionit në skedar, treguesi zhvendoset me n * bajt të madhësisë.

Për kontrolli në fund të skedarit ekziston një funksion feof:

int feof (FILE * emri i skedarit);

Ai kthehet jozero nëse është arritur fundi i skedarit.

SHEMBULL:

Krijoni një skedar binar D: \\ lojë \\ noobs.dat dhe shkruani një numër të plotë n dhe n numra realë në të.

#include "stdafx.h"

#përfshi

duke përdorur hapësirën e emrave std;

int main ()

setlocale (LC_ALL, "RUS");

int n, i;

dyfishi a;

// krijoni një skedar binar në modalitetin e shkrimit

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

// hyrje numratn

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

fshkruani (& n, madhësia e (int), 1, f);

// cikli për futjen e n numrave realë

për (i = 0; i

// futja e numrit real të radhës

cout<<"a=";

cin >> a;

// shkruani një numër real në një skedar binar

fshkruani (& a, madhësia e (dyfishtë), 1, f);

// mbyll dosje

fclose (f);

sistemi ("pauzë");

kthimi 0;

SHEMBULL:

Shfaqni përmbajtjen e skedarit binar D: \\ lojë \\ noobs.dat krijuar në detyrën e mëparshme

#include "stdafx.h"

#përfshi

duke përdorur hapësirën e emrave std;

int main ()

setlocale (LC_ALL, "RUS");

int n, i;

dyfishtë * a;

SKEDA * f; // përshkruani variablin e skedarit

// hapni një skedar binar ekzistues në modalitetin e leximit

// lexoni nga skedari një numër i plotë në ndryshoren n

// shfaq n në ekran

cout<<"n="<

// alokimi i memories për një grup prej n numrash

a = dyfish i ri [n];

// lexoni n numra realë nga skedari në grup a

// shfaq grupin në ekran

për (i = 0; i

cout<

cout<

// mbyll dosje

fclose (f);

sistemi ("pauzë");

kthimi 0;

Skedar binar- struktura sekuenciale e të dhënave, pas hapjes së skedarit, biti i parë i ruajtur në të është i disponueshëm. Ju mund të shkruani ose lexoni të dhëna në mënyrë të njëpasnjëshme nga një skedar. Le të themi se dëshironi të numëroni numrin e pesëmbëdhjetë, dhe më pas të parin. Me akses sekuencial, kjo mund të bëhet në mënyrën e mëposhtme:

int n, i;

dyfishi a;

SKEDA * f;

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

për (i = 0; i<15; i++)

fclose (f);

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

fread (& a, madhësia e (dyfishtë), 1, f);

fclose (f);

Siç mund ta shihni, leximi i numrave nga një skedar në këtë mënyrë dhe më pas rihapja e skedarit nuk është mënyra më e përshtatshme. Është shumë më i përshtatshëm për të përdorur funksionin fseek për të zhvendosur treguesin e skedarit në një bajt të caktuar.

int fseek (FILE * emri i skedarit, int offset i gjatë, origjina int);

Funksioni vendos treguesin në pozicionin aktual të skedarit F sipas vlerës së origjinës dhe zhvendosjes. Parametri i kompensimit është i barabartë me numrin e bajteve me të cilat treguesi i skedarit do të zhvendoset nga origjina e specifikuar nga parametri i origjinës. Parametri i origjinës duhet të jetë një nga vlerat e mëposhtme të kompensimit siç përcaktohet në kokën stdio.h:

SEEK_SET - nga fillimi i skedarit;

SEEK_CUR - nga pozicioni aktual;

SEEK_END - nga fundi i skedarit.

Funksioni kthen zero nëse operacioni është i suksesshëm, jo ​​zero nëse ndodh një gabim gjatë ekzekutimit të një kompensimi

Funksioni fseek në të vërtetë zbaton qasje të drejtpërdrejtë në çdo vlerë në skedar. Thjesht duhet të dini vendndodhjen (numrin e bajtit) të vlerës në skedar. Le të shohim përdorimin e aksesit të drejtpërdrejtë në binare duke përdorur shembullin e zgjidhjes së problemit të mëposhtëm.

SHEMBULL

Në skedarin binar të gjeneruar më parë D: \\ lojë \\ noobs.dat, ndërroni numrat realë më të mëdhenj dhe më të vegjël.

Algoritmi për zgjidhjen e problemit përbëhet nga fazat e mëposhtme:

leximi i atyre reale nga skedari në grup a.

kërkoni në grupin a për vlerat maksimale (max) dhe minimale (min) dhe numrat e tyre (imax, imin).

zhvendosni treguesin e skedarit në vlerën maksimale dhe shkruani min.

zhvendosni treguesin e skedarit në vlerën minimale dhe shkruani max.

Më poshtë është teksti i programit për zgjidhjen e problemit me komente.

#include "stdafx.h"

#përfshi

duke përdorur hapësirën e emrave std;

int main ()

setlocale (LC_ALL, "RUS");

int n, i, imax, imin;

dyfishtë * a, max, min;

SKEDA * f;

// hap skedarin në modalitetin e leximit dhe shkrimit

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

// lexoni shumën nga skedari në variablin n

// numrat realë në skedar

fread (& n, madhësia e (int), 1, f);

cout<<"n="<

// caktoni memorie për ruajtjen e numrave realë,

// e cila do të ruhet në grup a

a = dyfish i ri [n];

// lexoni nga skedari në grup dhe numra realë

fread (a, madhësia e (dyfishtë), n, f);

// gjeni elementet maksimale dhe minimale

// në grupin a dhe indekset e tyre

për (imax = imin = 0, max = min = a, i = 1; i

nëse (a [i]> max)

max = a [i];

nëse (a [i]

min = a [i];

// duke lëvizur tregues për të maksimale element

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

// shkruani min në vend të elementit maksimal të skedarit

fshkruani (& min, madhësia e (dyfish), 1, f);

// duke lëvizur tregues për të minimale element

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

// shkruani max në vend të elementit minimal të skedarit

fwrite (& max, madhësia e (dyfish), 1, f);

// mbyll skedarin

fclose (f);

// memorie e lirë

fshi [ ] a;

sistemi ("pauzë");

Për lehtësi referimi, informacioni në pajisjet e ruajtjes ruhet në formën e skedarëve.

Skedari është një zonë e emërtuar e memories së jashtme e caktuar për ruajtjen e një grupi të dhënash. Të dhënat që përmbajnë skedarët janë të natyrës më të larmishme: programe në gjuhën algoritmike ose të makinës; të dhënat fillestare për funksionimin e programeve ose rezultatet e ekzekutimit të programeve; tekste arbitrare; grafike etj.

Drejtori (dosje, drejtori) - një koleksion i emërtuar i bajteve në një medium ruajtjeje, që përmban emrin e nëndirektorive dhe skedarëve, përdoret në sistemin e skedarëve për të thjeshtuar organizimin e skedarëve.

Sistemi i skedarëveështë pjesa funksionale e sistemit operativ që ofron operacione në skedarë. Shembuj të sistemeve të skedarëve janë FAT (FAT - Tabela e ndarjes së skedarëve), NTFS, UDF (përdoret në CD).

Ekzistojnë tre versione kryesore të FAT: FAT12, FAT16 dhe FAT32. Ato ndryshojnë në thellësinë e bitit të regjistrimeve në strukturën e diskut, d.m.th. numri i biteve të alokuara për ruajtjen e numrit të grupimit. FAT12 përdoret kryesisht për disqe (deri në 4 KB), FAT16 për disqe të vegjël, FAT32 për disqe FLASH me kapacitet të lartë (deri në 32 GB).

Le të shohim strukturën e sistemit të skedarëve duke përdorur FAT32 si shembull.

Struktura e skedarit FAT32

Pajisjet e memories së jashtme në sistemin FAT32 nuk kanë bajt, por bllokojnë adresimin. Informacioni shkruhet në pajisjen e memories së jashtme në blloqe ose sektorë.

Një sektor është njësia më e vogël e adresueshme e ruajtjes së informacionit në pajisjet e ruajtjes së jashtme. Në mënyrë tipike, madhësia e sektorit fiksohet në 512 bajt. Për të rritur hapësirën e adresave të pajisjeve të memories së jashtme, sektorët kombinohen në grupe të quajtura grupe.

Një grup është një bashkim i disa sektorëve, i cili mund të konsiderohet si një njësi e pavarur me veti të caktuara. Vetia kryesore e një grupi është madhësia e tij, e matur në numrin e sektorëve ose numrin e bajteve.

Sistemi i skedarëve FAT32 ka strukturën e mëposhtme.

Grupet e përdorura për regjistrimin e skedarëve numërohen duke filluar nga 2. Si rregull, grupi # 2 përdoret nga direktoria rrënjësore, dhe duke filluar nga grupi # 3, ruhet një grup të dhënash. Sektorët e përdorur për të ruajtur informacionin e paraqitur më lart në direktorinë rrënjë nuk janë të grupuar.
Madhësia minimale e skedarit në disk është 1 grup.

Sektori i nisjes fillon me informacionin e mëposhtëm:

• EB 58 90 - dega dhe nënshkrimi i pakushtëzuar;
• 4D 53 44 4F 53 35 2E 30 MSDOS5.0;
• 00 02 - numri i bajteve në sektor (zakonisht 512);
• 1 bajt - numri i sektorëve në grup;
• 2 bajt - numri i sektorëve rezervë.

Përveç kësaj, sektori i nisjes përmban informacionin e mëposhtëm të rëndësishëm:

• 0x10 (1 bajt) - numri i tabelave FAT (zakonisht 2);
• 0x20 (4 bytes) - numri i sektorëve në disk;
• 0x2С (4 bytes) - numri i grupit të drejtorisë rrënjësore;
• 0x47 (11 bytes) - etiketa e vëllimit;
• 0x1FE (2 bytes) - nënshkrimi i sektorit të nisjes (55 AA).

Sektori i informacionit të sistemit të skedarëve përmban:

• 0x00 (4 bytes) - nënshkrimi (52 52 61 41);
• 0x1E4 (4 bytes) - nënshkrimi (72 72 41 61);
• 0x1E8 (4 bytes) - numri i grupimeve të lira, -1 nëse nuk dihet;
• 0x1EC (4 bytes) - numri i grupit të fundit të regjistruar;
• 0x1FE (2 bytes) - nënshkrimi (55 AA).

FAT përmban informacione për gjendjen e çdo grupi në disk. 2 bajtët e poshtëm të FAT ruajnë F8 FF FF 0F FF FF FF FF (që korrespondon me gjendjen e grupimeve 0 dhe 1, të cilat mungojnë fizikisht). Më tej, gjendja e çdo grupi përmban numrin e grupit në të cilin vazhdon skedari aktual ose informacionin e mëposhtëm:

• 00 00 00 00 - grupi është falas;
• FF FF FF 0F - fundi i skedarit aktual.

• 8 byte - emri i skedarit;
• 3 bajt - zgjerimi i skedarit;

Drejtoria kryesore përmban një grup të dhënash informacioni 32-bit për çdo skedar, që përmban informacionin e mëposhtëm:

Kur punoni me emra të gjatë të skedarëve (përfshirë emrat rusë), emri i skedarit kodohet në sistemin e kodimit UTF-16. Në këtë rast, 2 bajt ndahen për kodimin e çdo karakteri. Në këtë rast, emri i skedarit shkruhet në formën e strukturës së mëposhtme:

• 1 bajt sekuence;
• 10 bajt përmbajnë 5 karakteret më pak të rëndësishme të emrit të skedarit;
• atribut 1 bajt;
• 1 bajt i rezervuar;
• 1 bajt - shuma kontrolluese e emrit të DOS;
• 12 bajt përmbajnë 3 karakteret më pak të rëndësishme të emrit të skedarit;
• 2 byte - numri i grupit të parë;
• personazhe të tjerë të emrit të gjatë.

Puna me skedarë në gjuhën C

Për programuesin, një skedar i hapur përfaqësohet si një sekuencë e të dhënave që lexohen ose shkruhen. Kur hapet një skedar, ai lidhet me I/O rrymë... Informacioni dalës shkruhet në rrjedhë, informacioni hyrës lexohet nga transmetimi.

Kur hapet një transmetim për I/O, ai lidhet me një strukturë standarde të tipit FILE, e cila përcaktohet në stdio.h. Struktura FILE përmban informacionin e nevojshëm për skedarin.

Skedari hapet duke përdorur funksionin fopen (), i cili kthen një tregues në një strukturë FILE, e cila mund të përdoret për operacionet e mëvonshme me skedarin.

FILE * fopen (emri, lloji);

emri - emri i skedarit që do të hapet (përfshirë shtegun),
lloji është një tregues për një varg karakteresh që përcaktojnë se si të aksesoni skedarin:

• "r" - hapni një skedar për lexim (skedari duhet të ekzistojë);
• "w" - hapni një skedar bosh për shkrim; nëse skedari ekziston, atëherë përmbajtja e tij humbet;
• "a" - hapni skedarin për shkrim deri në fund (për shtim); skedari krijohet nëse nuk ekziston;
• "r +" - hapni një skedar për lexim dhe shkrim (skedari duhet të ekzistojë);
• "w +" - hapni një skedar bosh për lexim dhe shkrim; nëse skedari ekziston, atëherë përmbajtja e tij humbet;
• "a +" - hapni skedarin për lexim dhe shtim, nëse skedari nuk ekziston, atëherë ai krijohet.

Vlera e kthyer është një tregues për rrjedhën e hapur. Nëse haset një gabim, kthehet NULL.

Funksioni fclose () mbyll transmetimin ose transmetimet që lidhen me skedarët e hapur me fopen (). Rrjedha për mbyllje përcaktohet nga argumenti i funksionit fclose ().

Vlera e kthyer: vlera 0, nëse transmetimi u mbyll me sukses; EOF konstante nëse ka ndodhur një gabim.

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

#përfshi
int main () (
FILE * fp;
emri char = "my.txt";
nëse ((fp = fopen (emri, "r")) == NULL)
{
printf ( "Dosja nuk mund të hapej");
getchar ();
kthimi 0;
}
// hapni skedarin me sukses
... // veprimet e nevojshme mbi të dhënat
fclose (fp);
getchar ();
kthimi 0;
}

Leximi i një karakteri nga një skedar:

char fgetc (lumë);

Argumenti i funksionit është një tregues drejt një rryme të tipit FILE. Funksioni kthen kodin e karakterit të lexuar. Nëse arrihet fundi i skedarit ose ndodh një gabim, EOF konstante kthehet.

Shkrimi i një karakteri në një skedar:

fputc (personazh, rrymë);

Argumentet e funksionit janë një karakter dhe një tregues drejt një rryme të tipit FILE. Funksioni kthen kodin e karakterit të lexuar.

Funksionet fscanf () dhe fprintf () janë të ngjashme me funksionet scanf () dhe printf (), por ato punojnë me skedarët e të dhënave dhe marrin një tregues skedari si argumentin e parë.

fscanf (stream, "Input Format", argumente);

Mekanizmi i zhvilluar I / O nuk korrespondon me stilin e pranuar përgjithësisht të programimit të orientuar nga objekti, përveç kësaj, ai përdor në mënyrë aktive operacione me tregues, të cilët konsiderohen potencialisht të pasigurt në mjediset moderne të ekzekutimit të kodit të mbrojtur. Një alternativë gjatë zhvillimit të aplikacioneve të aplikuara është mekanizmi i klasave standarde I / O të ofruara nga standardi i gjuhës C ++.

Hapja e skedarëve

Klasat më të përdorura janë ifstream për lexim, ofstream për shkrim dhe fstream për modifikimin e skedarëve.

Të gjitha klasat e transmetimit I / O rrjedhin në mënyrë indirekte nga paraardhësi i përbashkët i ios, duke trashëguar plotësisht funksionalitetin e tij. Kështu, mënyra e hapjes së skedarëve specifikohet nga anëtari i të dhënave të tipit të numëruar open_mode, i cili përcaktohet si më poshtë:

Enum open_mode (app, binary, in, out, trunc, ate);

Më poshtë janë vlerat e mundshme të flamujve dhe qëllimi i tyre.

Për shembull, për të hapur një skedar të quajtur test.txt për të lexuar të dhënat në formë binare, shkruani:

skedari Ifstream; file.open ("test.txt", ios :: në | ios :: binar);

Operatori logjik OR (|) ju lejon të krijoni një modalitet me çdo kombinim flamujsh. Kështu që, kur hapni një skedar duke regjistruar, të mos mbishkruani aksidentalisht një skedar ekzistues me të njëjtin emër, duhet të përdorni formularin e mëposhtëm:

Skedari jashtë rrjedhës; file.open ("test.txt", ios :: jashtë | ios :: app);

Supozohet se skedari përkatës i kokës është i lidhur me projektin:

#përfshi

Për të kontrolluar nëse skedari u hap me sukses, mund të përdorni konstruksionin

Nëse (! Skedari) (// Trajto gabimin e hapjes së skedarit)

Përfshi dhe merr operatorët

E anashkaluar në klasat e trajtimit të skedarëve operatori i përfshirjes (<<) записывает данные в файловый поток. Как только вы открыли файл для записи, можно записывать в него текстовую строку целиком:

Skedari<< "Это строка текста";

Ju gjithashtu mund të shkruani vargun e tekstit pjesë-pjesë:

Skedari<< "Это " << "строка " << "текста";

Deklarata endl përfundon hyrjen me një kthim:

Skedari<< "Это строка текста" << endl;

Duke përdorur operatorin e përfshirjes, është e lehtë të shkruani vlerat e variablave ose elementëve të grupit në një skedar:

Skedari jashtë rrjedhës ("Temp.txt"); char buff = "Rreth teksti përmban variabla"; int vx = 100; float pi = 3,14159; dosje<< buff << endl << vx << endl << pi << endl;

Si rezultat i ekzekutimit të kodit, formohen tre rreshta të skedarit të tekstit Temp.txt:

Vargu i tekstit përmban variabla 100 3.14159

Vini re se vlerat numerike shkruhen në skedar si vargje teksti, jo si vlera binare.

Operatori i ekstraktit(>>) bën të kundërtën. Duket se për të nxjerrë simbole nga skedari Temp.txt i regjistruar më parë, duhet të shkruani kodin si më poshtë:

Skedari Ifstream ("Temp.txt"); char buff; int vx; noton pi; skedar >> buff >> vx >> pi;

Megjithatë, operatori i nxjerrjes do të ndalet në kufirin e parë (hapësirën, skedën ose karakterin e linjës së re) që gjen. Kështu, kur analizohet fjalia "Tekst array përmban variabla" vetëm fjala "Text" do të shkruhet në grupin buff, hapësira shpërfillet dhe fjala "array" do të bëhet vlera e ndryshores së plotë vx, dhe kodi ekzekutimi do të "bëjë i egër" me një shkelje të pashmangshme të strukturës së të dhënave. Më pas, kur diskutojmë klasën ifstream, do t'ju tregojmë se si ta organizoni siç duhet leximin e skedarit nga shembulli i mëparshëm.

Klasa Ifstream: leximi i skedarëve

Siç nënkupton edhe emri, klasa ifstream ka për qëllim të futë një transmetim skedari. Më poshtë janë metodat kryesore të klasës. Shumica e tyre janë trashëguar nga klasa istream dhe janë të mbingarkuar me funksione të zgjeruara prindërore. Për shembull, funksioni marrë, në varësi të parametrit të thirrjes, mund të lexojë jo vetëm një karakter të vetëm, por edhe një bllok karakteresh.

Tani është e qartë se si duhet të modifikoni shembullin e mëparshëm në mënyrë që përdorimi i operatorit të rikthimit të të dhënave të japë rezultatin e pritur:

Skedari Ifstream ("Temp.txt"); char buff; int vx; noton pi; file.getline (buff, sizeof (buff)); skedar >> vx >> pi:

Metoda getline do të lexojë rreshtin e parë të skedarit deri në fund, dhe operatori >> do t'u caktojë vlera variablave.

Shembulli i mëposhtëm tregon shtimin e të dhënave në një skedar teksti dhe më pas leximin e të gjithë skedarit. Cikli while (1) përdoret në vend të while (! File2.eof ()) për arsyet e diskutuara në.

#përfshi #përfshi duke përdorur hapësirën e emrave std; int main () (ofstream file; file.open ("test.txt", ios :: out | ios :: app); if (! file) (cout<< "File error - can"t open to write data!"; cin.sync(); cin.get(); return 1; } for (int i=0; i<10; i++) file << i << endl; file.close(); ifstream file2; file2.open("test.txt", ios::in); if (!file2) { cout << "File error - can"t open to read data!"; cin.sync(); cin.get(); return 2; } int a,k=0; while (1) { file2 >> a; nëse (file2.eof ()) thyej; cout<< a << " "; k++; } cout << endl << "K=" << k << endl; file2.close(); cin.sync(); cin.get(); return 0; }

Shembulli i mëposhtëm tregon një lak për të lexuar rreshtat nga skedari test.txt dhe për t'i shfaqur ato në tastierë.

#përfshi #përfshi duke përdorur hapësirën e emrave std; int main () (skedari ifstream; // krijo skedarin e skedarit të objektit të transmetimit.hap ("test.txt"); // hap skedarin për lexim nëse (! skedar) kthen 1; // kthej në gabimin e hapur char str; // tampon linja statike // Lexoni dhe shfaqni linjat në një lak deri në eof ndërsa (! file.getline (str, sizeof (str)). eof ()) cout<< str << endl; // вывод прочитанной строки на экран cin.sync(); cin.get(); return 0; }

Ky kod nën sistemin operativ Windows varet gjithashtu nga prania e një karakteri të furnizimit të linjës në rreshtin e fundit të skedarit, do të ishte më e sigurt ta bëni këtë:

Ndërsa (1) (nëse (file.eof ()) thyejnë; file.getline (str, sizeof (str)); cout<< str << endl; }

Thirrjet e qarta në metodat e hapjes dhe mbylljes janë opsionale. Në të vërtetë, thirrja e konstruktorit me një argument ju lejon të hapni menjëherë një skedar në kohën e krijimit të një skedari të objektit të transmetimit:

Skedari Ifstream ("test.txt");

Në vend të metodës së mbylljes, mund të përdorni operatorin e fshirjes, i cili automatikisht do të thërrasë destruktorin e objektit të skedarit dhe do të mbyllë skedarin. Kodi i ciklit while siguron që fundi i skedarit të kontrollohet siç duhet.

Klasa offstream: shkrimi i skedarëve

Klasa ofstream është krijuar për të nxjerrë të dhëna nga një rrjedhë skedari. Më poshtë janë metodat kryesore të kësaj klase.

Operatori i përfshirjes i përshkruar më parë është i përshtatshëm për organizimin e shkrimit në një skedar teksti:

Skedari jashtë rrjedhës ("temp.txt"); nëse (! file) kthehen; për (int i = 1; i<=3; i++) file << "Строка " << i << endl; file.close();

Skedarët binare

Në thelb, të dhënat binare shërbehen si të dhëna teksti. Dallimi është se nëse të dhënat binare shkruhen në një strukturë të caktuar logjike, atëherë ato duhet të lexohen nga skedari në një variabël të të njëjtit lloj strukture.

Parametri i parë i metodave të shkrimit dhe leximit (adresa e bllokut të shkrimit / leximit) duhet të ketë llojin e treguesit të karakterit char *, kështu që duhet të kryhet një konvertim i qartë i llojit të adresës së strukturës void *. Parametri i dytë specifikon që blloqet binare të skedarit kanë një madhësi konstante bajt, pavarësisht nga gjatësia aktuale e regjistrimit. Shtojca e mëposhtme jep një shembull se si të krijohen dhe shfaqen të dhënat për një fletore bazë. Të dhënat e skedarit më pas lexohen në mënyrë sekuenciale dhe shfaqen në tastierë.

#përfshi #përfshi #përfshi duke përdorur hapësirën e emrave std; struct Shënime (// struktura e të dhënave të fletores char Emri; // emri i plotë char Telefoni; // telefon int Mosha; // mosha); int main () (setlocale (LC_ALL, "Rusisht"); Shënime Shënim1 = ("Ivan i Tmerrshëm", "jo i instaluar", 60); Shënime Shënim2 = ("Boris Fedorovich Godunov", "095-111-2233", 30); Shënime Shënim 3 = ("Romanov Petr Mikhailovich", "812-333-2211", 20); ofile ofile ("Notebook.dat", ios :: binar); ofile.write ((char *) & Shënim1, sizeof (Shënime)); // Blloku i parë i fotografisë. shkruaj ((char *) & Shënimi 2, madhësia e (Shënime)); // Blloku i dytë ofile.shkruaj ((char *) & Shënimi 3, madhësia e (Shënime)); / / Blloku i 3-të ofile.close (); // mbyll skedarin e regjistruar ifstream ("Notebook.dat", ios :: binar); Shënime Shënim; // variabli i strukturuar char str; // buffer i vargut statik // Lexoni dhe shfaqni linjat në një lak deri në eof ndërsa (! ifile.read ((char *) & Shënim, madhësia e (Shënime)). eof ()) (sprintf (str, "% s \ t Trupi:% s \ t Mosha:% d" , Shënim.Emri, Shënim.Telefon, Shënim.Mosha); cout<< str << endl; } ifile.close(); // закрыть прочитанный файл cin.sync(); cin.get(); return 0; }

Si rezultat i ekzekutimit të këtij kodi, një skedar binar Notebook.dat formohet nga tre blloqe me nga 80 bajt secili (me kusht që karakteret të jenë me një bajt). Natyrisht, ju mund të përdorni metoda të tjera transmetimi dhe të kryeni ndonjë operacion në fushat e një strukture specifike të të dhënave.

Klasa Fstream: akses i rastësishëm i skedarëve

Supozoni se ka 100 shënime në fletoren tonë dhe ne duam të numërojmë të 50-tën. Sigurisht, ju mund të organizoni një lak dhe të lexoni të gjitha regjistrimet nga i pari në atë të dhënë. Natyrisht, një zgjidhje më e synuar është të vendosni treguesin e pozicionit të skedarit pos drejtpërdrejt në regjistrimin 50 dhe ta lexoni atë:

Ifstream ifile ("Notebook.dat", ios :: binar); int pos = 49 * sizeof (Shënime); ifile.kërkoj (pos); // gjeni hyrjen e 50-të Shënime Shënim; // Shënime - struktura e mësipërme "record" ifile.read ((char *) & Note, sizeof (Shënime));

Kërkimet si këto janë efektive nëse skedari përbëhet nga regjistrime të një madhësie të njohur dhe konstante. Për të zëvendësuar përmbajtjen e një hyrje arbitrare, duhet të hapni rrjedhën e daljes në modalitetin e modifikimit:

Ofile ofile ("Notebook.dat", ios :: binare | ios :: ate); int pos = 49 * sizeof (Shënime); ofile seekp (pos); // kërkoni për rekordin e 50-të Shënime Shënime50 = ("Boris Yeltsin", "095-222-3322", 64); ofile.write ((char *) & Shënim, sizeof (Shënime)); // zëvendësim

Nëse nuk specifikoni flamurin ios :: ate (ose ios :: app), atëherë kur hapni skedarin binar Notebook.dat, përmbajtja e tij e mëparshme do të fshihet!

Më në fund, mund të hapni një skedar në të njëjtën kohë për lexim / shkrim duke përdorur metoda të trashëguara nga klasa e rrjedhës fstream nga paraardhësit e saj. Meqenëse klasa fstream rrjedh nga istream dhe ostream (përkatësisht prindërit e ifstream dhe ofstream), të gjitha metodat e përmendura më parë janë të disponueshme në aplikacion.

Shembulli i mëposhtëm ndërron hyrjen e parë dhe të tretë në skedarin Notebook.dat.

#përfshi #përfshi #përfshi duke përdorur hapësirën e emrave std; struct Shënime (Emri char; Telefoni char; mosha int;); int main () (setlocale (LC_ALL, "Rusisht"); Shënime Shënim1, Shënim3; // Hap skedarin për lexim / shkrim në të njëjtën kohë skedarin fstream ("Notebook.dat", ios :: binar | ios :: në | ios :: out); file.seekg (2 * sizeof (Shënime)); // gjeni dhe lexoni skedarin Note3.read ((char *) & Note3, sizeof (Shënime)); file.seekg (0); // gjeni dhe lexoni skedarin Note1.read ((char *) & Note1, sizeof (Shënime)); file.seekg (0); // Shënim1<== Note3 file.write((char*)&Note3, sizeof(Notes)); file.seekg(2 * sizeof(Notes)); // Note3 <== Note1 file.write((char*)&Note1, sizeof(Notes)); char str; // Считывать и отображать записи в цикле, пока не eof file.seekg(0); // вернуться к началу файла while (!file.read((char*)&Note1, sizeof(Notes)).eof()) { sprintf(str, "%s\tТел: %s\tВозраст: %d", Note1.Name, Note1.Phone, Note1.Age); cout << str << endl; } file.close(); cin.sync(); cin.get(); return 0; }

Flamujt ios :: in dhe ios :: out duhet të specifikohen në konstruktorin e objektit të skedarit, duke lejuar operacione të njëkohshme leximi dhe shkrimi. Si rezultat i ekzekutimit të këtij kodi, të dhënat e para dhe të treta të skedarit binar Notebook.dat shkëmbehen.

Ka shembuj shtesë për këtë temë.