Kezelés bináris fájlokat ac

Amikor a felvétel információ bináris szimbólumok, számok vannak írva, mint bájtok sorozata.

Annak érdekében, hogy adatokat írjanak egy bináris fájlt kell tennie:

1. leírja a fájltípus változó FAIL * A FILE * fájlnév operátor. Itt fájlnév - a változó nevét, amely tárolja a fájl mutatót.
2. nyissa meg a fájlt az fopen
3. levelet az információt egy fájlt fwrite funkciók
4. zárja be a fájlt fclose funkció
   

Annak érdekében, hogy olvassa el az adatokat a bináris fájlt kell tennie:

1. leírni egy változó típusú FILE *
2. nyissa meg a fájlt az fopen
3. hogy az információt egy fájlból a fread funkciót. ugyanakkor arról, hogy vajon a fájl végére elérte.
4. zárja be a fájlt fclose funkció

Tekintsük az alapvető funkciók szükséges dolgozni bináris fájlokat.

A fájl megnyitásához tervezett funkció fopen.

FILE * fopen (const * fájlnév, const char * módban)

Itt fájlnév - egy string, amely tartalmazza a teljes neve a fájlt megnyitni, mód - egy karakterlánc, amely a működési mód a fájlt; Van jelentése a következő:

• «Rb» - nyitott bináris fájl csak olvasható módban
• «Wb» - hozzon létre bináris fájl írásra; ha létezik, annak tartalmát törli;
• «Ab» - hozzon létre vagy nyisson meg egy bináris fájlt csatolja a fájlt;
• «Rb +» - megnyitja a meglévő bináris fájlt írásra és olvasásra;
• «Wb +» - nyitott bináris fájl írható-olvasható módban, a meglévő fájl törlődik;
• «Ab +» - egy bináris fájl megnyitásakor vagy létrehozott kijavítani a meglévő információk és új fájl végére.

A függvény a fájl változó f NULL érték meghibásodása esetén kell nyitnia egy fájlt. A fájl megnyitása után elérhető 0. annak bájt, a fájl mutató értéke 0, ami azért fontos, mert olvasásra vagy írásra eltolódik a read (írásbeli) bájt. Aktuális fájl mutatót - byte számot, amely lehet olvasni vagy írni működését.

Célja, hogy zárja be a fájlt fclose funkció:

int fclose (FILE * fájlnév);

0 visszaadásával a siker, az ügy lezárásáról és EOF egyébként.

Az eltávolítás funkciót arra tervezték, hogy távolítsa el a fájlokat:

int eltávolítás (const char * fájlnév);

Ez a funkció eltávolítja a fájlt a lemezről a nevét filenema. Törli a fájlt le kell zárni. A függvény visszaküldi nulla, ha a fájl nem lehet eltávolítani.

Átnevezése fájl átnevezés funkció:

int átnevezés (const char * oldfilename, const char * newfilename);

Az első lehetőség - a régi fájl nevét, a második - új. Visszaadja 0 sikeres befejezése a program.

Olvasás bináris fájlból használatával fread funkció:

fread (void * ptr, mérete, n, FILE * fájlnév);

fread függvény olvas a fájlnév fájl egy tömb ptr n elemeinek mérete mérete. A függvény a tételek számát olvassa. Felolvasása után a fájl mutatót átkerül az n * méretét byte.

Az írás egy bináris fájl segítségével fwrite funkciók:

fwrite (const void * ptr, mérete, n, FILE * fájlnév);

fwrite funkciót ír a fájlnév a tömb ptr n elemeinek mérete mérete. A függvény a száma a rögzített elemeket. Rögzítése után az adatokat a fájl mutatót átkerül az n * méretét byte.

A szabályozás a fájl vége függvénye feof:

Ez visszaadja a nulla értéket, ha a végén a fájlt.

A pontosabb mastering anyag azt javaslom, hogy fontolja meg egy pár közös feladatokat.

Hozzon létre egy bináris fájl D: \\ \\ játék noobs.dat és írd bele egy egész n és n valós szám.

#include "stdafx.h"
#include
using namespace std;
int main # 40; # 41;
# 123;
setlocale # 40; LC_ALL "RUS" # 41; ;
int n, i;
Double A;
FILE * f; // írja a fájlt változó






// Létrehozunk egy bináris fájl írási üzemmódban
F = fopen # 40; "D: \\ \\ játék noobs.dat". "WB" # 41; ;
// bemeneti n szám
cout <<"n=" ; cin>> N;
fwrite # 40; N, sizeof # 40; int # 41;. 1. f # 41; ;
// ciklus bevitelére n valós szám
mert # 40; i = 0; én # 123;
// adjon meg egy másik valós szám
cout <<"a=" ;
cin >> a;
// veshestvennogo rekord számú bináris
fwrite # 40; egy, sizeof # 40; kettős # 41;. 1. f # 41; ;
# 125;
// bezárja a fájlt
fclose # 40; f # 41; ;
rendszer # 40; „Szünet” # 41; ;
vissza 0;
# 125;

Hogy a képernyőre a létrehozott tartalmat az utolsó feladatnál a bináris fájl D: \\ \\ játék noobs.dat

#include "stdafx.h"
#include
using namespace std;
int main # 40; # 41;
# 123;
setlocale # 40; LC_ALL "RUS" # 41; ;
int n, i;
kettős * a;
FILE * f; // írja a fájlt változó
// megnyit egy létező bináris fájl olvasási módban
F = fopen # 40; "D: \\ \\ játék noobs.dat". "Rb" # 41; ;
// olvasni egy fájlt egyetlen egész n változó
fread # 40; N, sizeof # 40; int # 41;. 1. f # 41; ;
// megjelenítése a képernyőn n
cout <<"n=" < // memória kiosztás egy tömb n számok
a = new kettős # 91; n # 93; ;
// olvasata n valós számok egy fájlból egy tömbben
fread # 40; egy, sizeof # 40; kettős # 41;. n, f # 41; ;
// nyomtatni a tömb a képernyőn
mert # 40; i = 0; én cout < cout < // bezárja a fájlt
fclose # 40; f # 41; ;
rendszer # 40; „Szünet” # 41; ;
vissza 0;
# 125;

Bináris fájl - szekvenciális adatszerkezet, megnyitása után a fájl első byte tárolja azt. Akkor egymás adatait olvasni vagy írni a fájlt. Tegyük fel, hogy szeretné-e számolni a tizenötödik, majd az első. Ezzel a szekvenciális hozzáférés tehető a következő módon:

int n, i;
Double A;
FILE * f;
F = fopen # 40; "D: \\ \\ játék noobs.dat". "Rb" # 41; ;
mert # 40; i = 0; én <15 ; i ++ )
fread # 40; egy, sizeof # 40; kettős # 41;. 1. f # 41; ;
fclose # 40; f # 41; ;
F = fopen # 40; "D: \\ \\ játék noobs.dat". "Rb" # 41; ;
fread # 40; egy, sizeof # 40; kettős # 41;. 1. f # 41; ;
fclose # 40; f # 41; ;

Mint látható, egy ilyen olvasata számok a fájlt, majd újra megnyitja a fájlt - nem a legkényelmesebb módon. Ez sokkal kényelmesebb használni a funkciót fseek mozgassa a fájl pointer a megadott byte.

int fseek (FILE * fájlnév, long int offset, int eredetű);

A függvény beállítja a mutatót a jelenlegi helyzetben a fájl F értéke szerint az eredetmegjelölések és a származási offset eltolás. Az eltolás paraméter megegyezik a bájtok számát, amelyek tolódik a fájl mutatót a vonatkoztatási által meghatározott eredetű. Ami az eredete a paraméterértékek kell venni, mint az egyik a következő előfeszítő offset referenciaértékeket. Bizonyos cím stdio.h:

• SEEK_SET - mivel az a fájl elején;
• SEEK_CUR - a jelenlegi helyzetben;
• SEEK_END - a fájl végére.

A függvény egy null értéket, ha a művelet sikeres volt, nem nulla - a hiba esetén, ha a torzítás

fseek funkció ténylegesen végrehajtja közvetlen hozzáférést bármelyik érték a fájlban. Ez csak akkor szükséges, hogy ismerjük a helyét (byte-szám) értékeket a fájlt. Fontolja meg az közvetlen hozzáférést biztosít a bináris fájlokat a megoldást a következő problémára.

A korábban előállított bináris fájl D: \\ \\ játék noobs.dat. cserélni a maximális és minimális a valós számokat.

Az algoritmus a probléma megoldásának az alábbi lépéseket:

1. olvasmányokat egy file-ba egy tömbbe.
2. keresés tömb és a maximális (max) és a minimális (min) értéket, és számuk (Imax. Imin).
3. mozog a fájl mutatót a maximális érték és min üzenet.
4. mozog a fájl mutatót a minimális érték és a max felvételt.

#include "stdafx.h"
#include
using namespace std;
int main # 40; # 41;
# 123;
setlocale # 40; LC_ALL "RUS" # 41; ;
int n, i, Imax, Imin;
dupla * a, max, min;
FILE * f;
// nyissa meg a fájlt írásra és olvasásra
F = fopen # 40; "D: \\ \\ játék noobs.dat". "Rb +" # 41; ;
// olvasni egy fájlt egy változó n számú
// valós számok a fájlban
fread # 40; N, sizeof # 40; int # 41;. 1. f # 41; ;
cout <<"n=" < // a memóriát tárolására valós számok,
// hogy lesznek tárolva a tömb
a = new kettős # 91; n # 93; ;
// olvasni a fájlt tömbbe és a valós számok
fread # 40; egy, sizeof # 40; kettős # 41;. n, f # 41; ;
// megtalálják a maximális és minimális elemei
// A tömb és indexek
mert # 40; Imax = Imin = 0. max = min = a # 91; 0 # 93;. i = 1; én # 123;
ha # 40; egy # 91; én # 93;> max # 41;
# 123;
max = a # 91; én # 93; ;
Imax = i;
# 125;
ha # 40; egy # 91; én # 93; # 123;
min = a # 91; én # 93; ;
Imin = i;
# 125;
# 125;
// Vigye a mutatót a maximális elem
fseek # 40; f, sizeof # 40; int # 41; + Imax * sizeof # 40; kettős # 41;. SEEK_SET # 41; ;
// rekord perc helyett a maximális fájl member
fwrite # 40; min, sizeof # 40; kettős # 41;. 1. f # 41; ;
// Vigye a mutatót a legkisebb elem
fseek # 40; f, sizeof # 40; int # 41; + Imin * sizeof # 40; kettős # 41;. SEEK_SET # 41; ;
// max felvétel helyett a fájlok minimális tag
fwrite # 40; max, sizeof # 40; kettős # 41;. 1. f # 41; ;
// bezárja a fájlt
fclose # 40; f # 41; ;
// szabad memória
töröl # 91; # 93; a;
rendszer # 40; „Szünet” # 41; ;
vissza 0;
# 125;

Tehát, megnéztük az alapelvek dolgozó fájlokat a C ++. A következő leckében találkozni fognak újra, így usvoyte őket a lehető legjobban.