Dolgozzon az adatokkal a c fájlból. Szöveges fájlok kezelése. Olvasás bináris fájlból és írjon rá

A C ++ I / O fájl szinte hasonló a szokásos munkához (de kis árnyalatokkal).

I / O osztályok

van három főfájl I / O osztályok a C ++ -ban:

hova (egy lány osztály);

fstream (az iostream leányvállalata).

Ezen osztályok segítségével egyirányú fájlbevitelt, egyirányú fájlkimenetet és kétirányú fájlbevitelt / kimenetet végezhet. Használja őket, csak az Fstream csatlakoznia kell.

Ellentétben cout, CIN, CERR és klumpa patakok, ami azonnal felhasználható, fájladatfolyam kifejezetten meg kell telepíteni a programozó. Ez azt jelenti, hogy nyisson meg egy fájlt olvasásra és / vagy a felvétel, akkor létre kell hozni egy objektumot a megfelelő file input osztály, meghatározva a fájl nevét, mint paramétert. Ezután a beszúrási operátorok használata (<<) или извлечения (>\u003e), Adatokat írhat egy fájlhoz, vagy olvashatja el a fájl tartalmát. Ezt követően a döntőbe kell zárni a fájlt: kifejezetten okozza szoros () módszer Vagy egyszerűen csak teszi az I / O fájl változó kilép a látási terület (az input / output fájl osztály lezárja ezt a fájlt automatikusan helyettünk).

Fájlkimenet

Írja be a használt fájlt osztály . Például:

#Inlude. #Inlude. #Inlude. // A kilépés () int Main () használatához (a Namespace STD használatával / / / / / / / / / Ha nem tudjuk megnyitni ezt a fájlt az adatok írásához, ha (!<< "Uh oh, SomeText.txt could not be opened for writing!" << endl; exit(1); } // Записываем в файл следующие две строчки outf << "See line #1!" << endl; outf << "See line #2!" << endl; return 0; // Когда outf выйдет из области видимости, то деструктор класса ofstream автоматически закроет наш файл }

#Inlude.

#Inlude. // a kilépéshez ()

int Main ()

névtér STD használatával;

// ofstream, hogy adatokat írjon a fájlba

// hozzon létre egy kisext.txt fájlt

ofstream outf ("néhaxtxt");

// Ha nem tudjuk megnyitni ezt a fájlt az adatok írásához

iFF (! outf)

// Ezután megjelenjen egy hibaüzenetet és hajtsa végre a kilépést ()

cERR.<< << endl ;

kilépés (1);

// Írja be a következő két sort a fájlhoz

outf.<< "See line #1!" << endl ;

outf.<< "See line #2!" << endl ;

vissza 0;

// Ha az OFF kijön a láthatósági területen, az Ostream osztály megsemmisítője automatikusan bezárja a fájlunkat

Ha megnézed a projektkönyvtárba ( PCM egy lapon, a Visual Studio-ban > "Nyissa meg a mappát") Látni fog egy olyan fájlt, amelyet néha neveztek.txt, amelyben a következő sorok:

Lásd az 1. sor!
Lásd a 2. sor!

Megjegyzés, akkor is használhatjuk () Egy szimbólum írása a fájlhoz.

Fájlbevitel

#Inlude. #Inlude. #Inlude. #Inlude. // kezelhető EXIT () int main () (használatával Névtér STD; // ifstream használt olvasni a fájl tartalmát // Igyekszünk olvasni a tartalmát a Sometext.txt gomb ifstream inf ( "sometext.txt "); // Ha nem tudjuk megnyitni ezt a fájlt, olvassa el a tartalmát, ha (! INF) (CERR<< "Uh oh, SomeText.txt could not be opened for reading!" << endl; exit(1); } // Пока есть данные, которые мы можем прочитать while (inf) { // То перемещаем эти данные в строку, которую затем выводим на экран string strInput; inf >\u003e Strinput; Cout.<< strInput << endl; } return 0; }

#Inlude.

#Inlude. // a kilépéshez ()

int Main ()

névtér STD használatával;

// IFstream a fájl tartalmának elolvasására szolgál

// Ha nem tudjuk megnyitni ezt a fájlt, olvassa el a tartalmát.

ha (! INF)

// Ezután megjelenítse a következő hibaüzenetet és hajtsa végre az EXIT ()

cERR.<< << endl ;

kilépés (1);

// miközben vannak olyan adatok, amelyeket olvashatunk

míg (INF)

// Mozgassa ezeket az adatokat a karakterláncra, amelyet ezután megjelenik a képernyőn

string Strinput;

inf \u003e\u003e Strinput;

cout.<< strInput << endl ;

vissza 0;

// Ha az INS kijön a láthatóság köréből, az IFstream osztályú destructor automatikusan zárja be a fájlunkat

Lát
Vonal
#1!
Lát
Vonal
#2!

Hmm, nem pontosan az, amit akartunk. Ahogy már ismerkedtünk az előző órákból, az extrakciós szolgáltató "formázott adatokkal", azaz Figyelmen kívül hagyja az összes teret, fület és egy új karakterláncot. Ahhoz, hogy az összes tartalom elolvassa, mivel az a rész (mint a fenti példában), használni kell getline () módszer:

#Inlude. #Inlude. #Inlude. #Inlude. // A kilépés () int Main () használatához (a Namespace STD; // Az IFSTREAM használata a fájlok tartalmának elolvasásához) // Megpróbáljuk olvasni az esetleges szöveg tartalmát. txt "); // Ha nem tudjuk megnyitni a fájlt, hogy elolvassa annak tartalmát, ha (!<< "Uh oh, SomeText.txt could not be opened for reading!" << endl; exit(1); } // Пока есть, что читать while (inf) { // То перемещаем то, что можем прочитать, в строку, а затем выводим эту строку на экран string strInput; getline(inf, strInput); cout << strInput << endl; } return 0; // Когда inf выйдет из области видимости, то деструктор класса ifstream автоматически закроет наш файл }

#Inlude.

#Inlude. // a kilépéshez ()

int Main ()

névtér STD használatával;

// IFSTREAM a fájlok tartalmának elolvasására szolgál

iFSTREAM INF ("Valamext.txt");

// Ha nem tudjuk megnyitni a fájlt, hogy elolvassa annak tartalmát.

ha (! INF)

// Ezután megjelenítse a következő hibaüzenetet és hajtsa végre az EXIT ()

cERR.<< "Uh oh, néha nem lehetett olvasni!"<< endl ;

kilépés (1);

míg (INF)

string Strinput;

getline (inf, strinput);

cout.<< strInput << endl ;

vissza 0;

// Ha az INS kijön a láthatóság köréből, az IFstream osztályú destructor automatikusan zárja be a fájlunkat

A program eredménye magasabb:

Pufferelt kimenet

Következtetés a C ++ -ban pufferelhető. Ez azt jelenti, hogy a fájlfolyamon megjelenő minden megjelenik közvetlenül a lemezen (egy adott fájlba). Ez történik, elsősorban a teljesítmény megfontolása. Ha a pufferadatok a lemezre vannak írva, ezt hívják tisztítópuffer. A puffer tisztításának egyik módja a fájl bezárása. Ebben az esetben a puffer összes tartalma a lemezre kerül, majd a fájl zárva lesz.

A következtetés a pufferelés általában nem probléma, de bizonyos körülmények között gondatlan újonnan érkezhet. Például, ha a pufferben és a programban tárolt adatok idő előtt befejezik végrehajtását (akár hiba vagy hívás következtében). Ilyen esetekben a fájlbeviteli / kimeneti osztályok megsemmisítései nincsenek végrehajtva, a fájlok soha nem záródnak le, a pufferek nem törlődnek, és az adatok örökre elveszik. Ezért jó ötlet az összes nyitott fájl explicit lezárása a kilépés () hívása előtt.

A puffer manuálisan is tisztítható ostream :: Flush () vagy küldés std :: flush. a kimeneti adatfolyamban. Ezen módszerek bármelyike \u200b\u200bhasznos lehet a puffer tartalmának azonnali felvételének biztosítása a program meghibásodása esetén.

Érdekes árnyalat: Mivel STD :: endl; Ezenkívül törli a kimeneti áramot, túlzott felhasználás (a szükségtelen puffer tisztításhoz vezető) befolyásolhatja a program teljesítményét (mivel a puffer tisztítása bizonyos esetekben költség-művelet lehet). Emiatt a programozók, akik törődnek a feladataik kód gyakran használják \\ n helyett STD :: Endl beszúrni egy új karakterlánc szimbólum a kimeneti stream elkerülése érdekében a felesleges puffer takarítás.

Fájlnyitási módok

Mi történik, ha megpróbálunk adatokat írni egy már meglévő fájlba? A fenti program újraindítása (a nagyon első) azt jelzi, hogy a forrásfájl teljesen felülíródik, ha a program újraindul. És mi van, ha hozzá kell adnunk az adatokat a fájl végéhez? Kiderül, hogy a fájlfolyam egy opcionális második paramétert tartalmaz, amely lehetővé teszi, hogy megadja a programozót, hogyan kell megnyitni a fájlt. Ezt a paramétert továbbíthatja következő zászlók (amelyek az iOS osztályban vannak):

alkalmazás. - megnyitja a fájlt a hozzáadott módban;

evett - az olvasás / felvétel előtt a fájl végéig megy;

bináris. - megnyitja a fájlt bináris módban (szöveges mód helyett);

bAN BEN. - megnyitja a fájlt olvasási módban (alapértelmezett az IFSTREAM);

ki. - megnyitja a fájlt felvételi módban (alapértelmezett az offream számára);

csepegtető - Törli a fájlt, ha már létezik.

Több zászlót is megadhat.

IFSTREAM alapértelmezés szerint az iOS :: in módban;

az ISTREAM alapértelmezés szerint az iOS: out módban működik;

Fstream működik Alapértelmezés szerint iOS módban :: in vagy ios :: Out, ami azt jelenti, hogy mind olvasható, mind a fájl tartalmát, és írjon adatokat a fájlba.

Most írjunk egy olyan programot, amely két sorot ad hozzá a korábban létrehozott valamikor.txt fájlhoz:

#Inlude. #Inlude. // a kilépéshez () #include használatához INT Main () (névtér STD használatával, // az iOS-zászló átvitele: alkalmazás, hogy jelentse az Fstream-t, hogy hozzáadjuk az adatokat a már meglévő fájladatokhoz, // nem fogjuk felülírni a fájlt. Nem kell Az iOS-zászló továbbítása :: out, // Mivel az ISTREAM-on alapértelmezés szerint az IOS :: OUT OUTFREAM OUTF mód :: out ofstream outf ("Valamiext.txt", iOS :: app); // Ha nem tudunk megnyitni egy fájlt Adatok írása, ha (! outf) (// Ezután adja meg a következő hibaüzenetet, és hajtsa végre a () CERR<< "Uh oh, SomeText.txt could not be opened for writing!" << endl; exit(1); } outf << "See line #3!" << endl; outf << "See line #4!" << endl; return 0; // Когда outf выйдет из области видимости, то деструктор класса ofstream автоматически закроет наш файл }

#Inlude.

#Inlude. // a kilépéshez ()

#Inlude.

int Main ()

névtér STD használatával;

// átadása az iOS-lobogó: alkalmazás, amely lehetővé teszi az Fstream jelentés, hogy hozzáadjuk az adatokat a már meglévő fájladatokhoz,

// nem fogjuk felülírni a fájlt. Nem kell továbbítanunk az iOS: o out lobogóját,

// Mivel az Alapértelmezés szerint az IOS :: OUT mód

ofstream outf ("néhaxtxt", ios :: app);

// Ha nem tudjuk megnyitni az adatfájlt

iFF (! outf)

// Ezután megjelenítse a következő hibaüzenetet és hajtsa végre az EXIT ()

cERR.<< "Uh oh, néha sem nyitott meg írásban!"<< endl ;

kilépés (1);

A fájlok lehetővé teszik a felhasználó számára, hogy nagy mennyiségű adatot olvasson közvetlenül a lemezről anélkül, hogy belépne a billentyűzetről. A fájlok két fő típusa van: szöveg és bináris.

Szöveg Bármilyen karakterből álló fájlok. Ők sorok szerint szervezik őket, amelyek mindegyike a szimbólummal végződik " végvonal ». A fájl végét maga a szimbólum jelzi " adja meg a fájlt ». Ha szöveges fájlban van írva, megtekintheti, hogy bármilyen szövegszerkesztőt használjon, az összes adat átalakul a karakter típusra, és szimbolikus formában tárolható.

BAN BEN bináris A fájlok adatait egy bizonyos méretű blokkok formájában olvassák és rögzítjük, amelyben az adatok bármilyen típusú és szerkezetet tárolhatnak.

A speciális adattípusokat a fájlok kezelésére használják szálak.Folyam ifstreamaz olvasási módban dolgozó fájlokkal szolgál, és hova Felvételi módban. A fájlok kezeléséhez mind a felvétel, mind az olvasás a patak. fstream.

A szövegfájlok használatakor a C ++ programokban csatlakoznia kell a könyvtárakat. iostream és Fstream.

A szövegfájlban szereplő adatok rögzítéséhez szükséges:

ismertesse a változó típusát hova.
nyisd ki..
információk megjelenítése a fájlhoz.
Ügyeljen arra, hogy bezárja a fájlt.

Adatok olvasása szöveges fájlból, meg kell:

ismertesse a változó típusát ifstream.
nyissa meg a fájlt a funkció használatával nyisd ki..
olvassa el az információkat az egyes adatrész olvasásakor, ellenőrizni kell, hogy a fájl vége elérni fog-e.
zárja be a fájlt.

Felvételi információkat szövegfájlban

Amint azt korábban említettük, hogy elkezdhesse a szöveges fájl kezelését, leírnia kell a típusváltozót hova. Például:

az fstream f;

Egy változó létrejön F. Információ rögzítése a fájlhoz. A következő lépésben a fájlt fel kell nyitni a felvételhez. Általánosságban elmondható, hogy az áramlási nyíláskezelő meg fogja vizsgálni:

F..nyisd ki.("Fájl", mód.);

Itt F. - A leírt változó hova, fájl - a teljes fájlnév a lemezen, mód. - Működési mód A fájl megnyitása. Ne feledje, hogy a teljes fájlnév megadásakor kétréteget kell telepítenie. A keringéshez, például egy fájlhoz accounts.txt, A mappában található webhelyek. lemezen D.A programnak meg kell adnia: D: \\\\ webhelyek \\\\ fiókok..txt.

A fájl az alábbi módok valamelyikében nyitható meg:

ios :: in. - Nyissa meg a fájlt az adatolvasási módban; Az üzemmód az alapértelmezett mód a patakokhoz. ifstream;
ios :: out. - Nyissa meg a fájlt az adatfelvétel módban (a meglévő fájlról szóló információ megsemmisült); Az üzemmód az alapértelmezett mód a patakokhoz. hova;
iOS :: alkalmazás. - Nyissa meg a fájlt az adatfelvétel módban a fájl végéig;
ios :: evett - a már megnyitott fájl végére lépjen;
iOS :: TRICK. - Clear fájl, ugyanaz történik az iOS :: OUT módban;
ios :: Nocreate. - ne hajtsa végre a fájl megnyitásának működését, ha nem létezik;
iOS :: NorePlace. - Ne nyisson meg meglévő fájlt.

A módparaméter hiányozhat, ebben az esetben a fájl az alapértelmezett módban nyílik meg a szálra.

A fájl sikeres megnyitása után (bármilyen módban) változóban F. tárolódik igaz., másképp hamis. Ez lehetővé teszi, hogy ellenőrizze a fájlnyitás működésének helyességét.

Nyissa meg a fájlt (példaként vegye be a fájlt D: \\\\ webhelyek \\\\ fiókok..txt) A felvételi módban az alábbi módszerek valamelyike:

Miután megnyitott egy fájlt felvételi módban, létrejön egy üres fájl, amelyben rögzíthet információt.

Ha meglévő fájlt szeretne megnyitni másolatban, akkor az értéket módban kell használnia. iOS :: alkalmazás..

A fájl felvételi módjának megnyitása után ugyanúgy írhatsz, mint a képernyőn, csak egy szabványos kimeneti eszköz helyett cout. Meg kell adnia a megnyitott fájl nevét.

Például írni a patakra F.változó a.A kimeneti operátor megnézi:

F.<

A szekvenciális kimenetre a patakhoz G. változók b., c., d. A kimeneti üzemeltető:

G.<

Az áramlásbezárást a kezelő segítségével végezzük:

F.Close ();

Példaként tekintse meg a következő feladatot.

1. feladat.

Hozzon létre egy szöveges fájlt D: \\\\ webhelyek.\\fiókok. .txt és írd hozzá n. valós számok.

Döntés

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

#A "STDAFX.H"
#Inlude.
#Inlude.
#Inlude.
névtér STD használatával;
int Main ()
{

int i, n;
kettős a;
// leírja az adatfolyamot, hogy írjon adatokat a fájlba
az fstream f;
// Nyissa meg a fájlt felvételi módban,
// ios :: Az üzemmód alapértelmezés szerint van beállítva
F.open ("D: \\\\ Sites \\\\ Fiókok.txt », ios :: out);
// Adja meg a valós számok számát
cout.<< «n=» ; cin >\u003e n;
// ciklus a valós számok megadásához
// és írja meg őket a fájlba
mert (i \u003d 0; i< n; i++ )
{
cout.<< «a=» ;
// A szám beírása
cin \u003e\u003e;
F.<< a<< «";
}
// árvízbezárás
F.Close ();
rendszer ("szünet");
vissza 0;
}

Információk olvasása szöveges fájlból

Annak érdekében, hogy információt olvasson egy szövegfájlból, leírnia kell a típusváltozót ifstream. Ezt követően meg kell nyitnia egy olvasási fájlt az üzemeltető segítségével nyisd ki.. Ha a változót hívják F., az első két üzemeltető ilyen lesz:

Miután megnyitott egy fájlt olvasási módban, olvashatja el az információt, csak a billentyűzeten, csak helyett cin. Meg kell adnia az áramlás nevét, amelyből az adatok megtörténnek.

Például az adatfolyamok olvasásához F. változóban A.A bemeneti operátor így fog kinézni:

F \u003e\u003e a;

A szövegszerkesztőben két számot osztottak meg, ha legalább az egyik karakter között van: egy hely, fül, a vég szimbólum. Nos, ha egy programozó előre ismeri, hogy hány és milyen értékeket tárolnak egy szövegfájlban. Mindazonáltal csak a fájlban tárolt értékek típusa gyakran ismert, míg a számuk eltérő lehet. Ahhoz, hogy megoldja ezt a problémát, meg kell olvasni az értékeket a fájlt felváltva, és mielőtt minden olvasás, ellenőrizze, hogy a fájl végére valósul meg. És segítsen ezt a funkciót F.eof (). Itt F.- Flow Name A funkció logikai értéket ad meg: igaz. vagy hamisAttól függően, hogy a fájl vége eléri-e.

Következésképpen a teljes fájl tartalmának olvasása a következőképpen írható:

Az anyag jobb asszimilációjára tekintse meg a feladatot.

2. feladat.

A szöveges fájl D: \\\\ \\\\ Game Accounts.txt tárolt valós számok, akkor jelenítse meg azokat a képernyőn, és kiszámítja a számuk.

Döntés

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

#A "STDAFX.H"
#Inlude.
#Inlude.
#Inlude.
#Inlude.
névtér STD használatával;
int Main ()
{
Setlocale (lc_all, "rus");
int n \u003d 0;
lebeg a;
Fstream f;
// Nyissa meg a fájlt olvasási módban
F.open ("D: \\\\ Sites \\\\ Fiókok.txt ») ;
// ha a fájlnyílás helyesen telt el, akkor
ha (f)
{
// ciklus az értékek olvasásához a fájlból; A ciklus végrehajtása megszakad,
// A fájl végének elérésekor ebben az esetben f.eof () visszaadja az igazságot.
míg (! F.eof ())
{
// Olvassa el a következő értéket az F áramlásról a
F \u003e\u003e a;
// Következtetés változó érték A képernyőn
cout.<< a<< «";
// a számok számának növelése
n ++;
}
// árvízbezárás
F.Close ();
// alkalom az olvasott számok számáról
cout.<< «n=» << n<< endl;
}
// Ha a fájlnyílás helytelenül telt el, a kimenet
// üzenetek hiánya egy ilyen fájl
egyébként cout.<< "A fájl nem létezik"<< endl;
rendszer ("szünet");
vissza 0;
}

Ezen a viszonylag volumetrikus lecke a szövegfájlokon befejeződött. A következő cikk megvizsgálja a manipuláció módszereit, amelyekkel a C ++ -n belül feldolgozzák.

Utolsó frissítés: 10/31/2015

A rendszer könyvtárakkal való együttműködésre. A Namespace két osztályt azonnal rendelnek: könyvtár és könyvtárfo.

Könyvtári osztály

A könyvtár osztály számos statikus módszert kínál a könyvtárkezeléshez. Néhány ilyen módszer:

Createdirectory: létrehoz egy könyvtárat a megadott útvonalútvonalon

Törlés (útvonal): Törli a könyvtárat a megadott útvonalútvonalon

Létezik (útvonal): Meghatározza, hogy van-e olyan könyvtár a megadott útvonalúton. Ha van, akkor igaz, ha nincs, akkor nincs, akkor hamis

GetDireceire (Path): kap egy listát a könyvtárakról az útvonalkatalógusban

Getfiles (PATH): Az útvonalkatalógusban szereplő fájlok listáját kapja

Mozgás (sourcedirname, cerdirname): A katalógus mozgatása

GETPARENT (PATH): A szülői katalógus megszerzése

CLASS DIECTIEFO.

Ez az osztály funkcionalitást biztosít a könyvtárak létrehozásához, törléséhez, mozgatásához és más könyvtári műveletekhez. Sok szempontból úgy néz ki, mint a könyvtár. Néhány tulajdonsága és módszere:

Hozzon létre (): Katalógust hoz létre

Createsubdirectory (út): létrehoz egy alkönyvtárat a megadott útvonalútra

Törlés (): Törli a katalógust

Van tulajdonság: Meghatározza, hogy van-e katalógus

GetDireceiaries (): kap egy listát a könyvtárakról

Getfiles (): A fájlok listáját kapja

MOVETO (DESTDIRNAME): mozgatja a katalógust

Szülői ingatlan: szülői katalógus megszerzése

Gyökér tulajdonság: Gyökérkatalógus megszerzése

Nézzük meg az ezen osztályok alkalmazásának példáit

A fájlok és alkönyvtárak listája
String dirname \u003d "C: \\\\"; ha (directory.Exists (dirname)) (Console.WriteLine ( "Subdatalogues:"); karakterlánc Dirs \u003d Directory.GetDirectories (könyvtárnév); foreach (String S Dirs) (Console.WriteLine (S);) Console.WriteLine ( ); Konzol.writeline ("fájlok:"); string fájlok \u003d könyvtár .getfiles (dirname); foreach (Console.writeline (S);)
Figyeljen a szekrények használatára a fájlnevekben. Vagy egy kettős fekvést használunk: "C: \\\\", akár egyetlen, de azelőtt, hogy a jel @: @ "C: Program fájlok"

Katalógus létrehozása
String Path \u003d @ "C: Somedir"; STRING SUBPATH \u003d @ "Program \\ Avalon"; DirectoryInfo dirinfo \u003d új DirectoryInfo (útvonal); ha (! dirinfo.Create ();) dirinfo.createsubdirectory (subpath);
Először ellenőrizze, és nincs ilyen könyvtár, mivel ha létezik, akkor lehetetlen megteremteni, és az alkalmazás hibás lesz. Ennek eredményeképpen a következő módja lesz: "C: Somedir \\ Program \\ Avalon"

Információt kap a katalógusról
STRING DIRNAME \u003d "C: Programfájlok"; DirectoryInfo dirinfo \u003d új DirectoryInfo (DirName); Konzol.Writeline ($ "katalógus neve: (dirinfo.name)"); Konzol.Writeline ($ "teljes katalógus neve: (dirinfo.fullname)"); Konzol.writeline ($ "katalógus létrehozása: (dirinfo.creationtime)"); Konzol.Writeline ($ "gyökérkönyvtár: (dirinfo.root)");
A katalógus eltávolítása

Ha egyszerűen alkalmazzuk a törlési módszert egy nem üres mappába, ahol bármilyen fájl vagy alkönyvtár van, az alkalmazás hibát dob. Ezért a további logikai típusú opciót át kell adnunk a törlési módszerre, amely jelzi, hogy a mappát törölni kell az összes tartalommal:
STRING DIRNAME \u003d @ "C: ValameFolder"; Próbálkozzon (DirectoryInfo Dirinfo \u003d New DirectoryInfo (DirName); dirinfo.delete (true); console.writeline ("katalógus távirányító");) fogás (kivétel ex) (konzol.writeline (ex.sessage);)
STRING DIRNAME \u003d @ "C: ValameFolder"; Directory.Delete (DirName, True);
Mozgó katalógus
String oldpath \u003d @ "c: \\ valahol"; Newpath \u003d @ "C: Somedir"; DirectoryInfo Dirinfo \u003d New DirectoryInfo (Oldpath); ha (dirinfo.exists && directory.exists (newpath) \u003d\u003d hamis) (dirinfo.moveto (Newpath);)
Ha mozog, akkor szem előtt kell tartani, hogy az új könyvtár, amelyben a régi könyvtár tartalmát szeretnénk meghozni, nem létezhet.

A kapcsolatfelvételi kényelem érdekében a tárolt eszközökkel kapcsolatos információkat fájlként tárolják.
A fájl az adatgyűjtés tárolásához elosztott külső memória terület. A fájlokban szereplő adatok a legkülönbözőbb karakterek: az algoritmikus vagy gép nyelvén található programok; Forrásadatok a programműveletekhez vagy a program végrehajtásának eredményeihez; önkényes szövegek; grafikus képek stb.
Katalógus (mappa, könyvtár) - A fájlrendszerben az alkönyvtárak és fájlok nevét tartalmazó információkat tartalmazó bájtok neve a fájlrendszerben használható a fájlok szervezésének egyszerűsítése érdekében.
Fájlrendszer Az operációs rendszer funkcionális része, amely biztosítja a fájlok műveleteinek végrehajtását. A fájlrendszerek példái a zsír (zsír - fájl elosztási táblázat, fájlmegjelenítési táblázat), NTFS, UDF (CD-k).
A zsír három fő verziója van: FAT12, FAT16 és FAT32. Ezek különböznek a lemezszerkezetben lévő rekordok kibocsátásában, azaz A klaszterszám tárolására fenntartott bitek száma. A FAT12-et elsősorban floppy lemezekhez (legfeljebb 4 KB), FAT16 - kis hangerő-lemezek, FAT32 - nagy kapacitású vaku-tárolóeszközökhöz (akár 32 GB).
Tekintsük a fájlrendszer szerkezetét a FAT32 példáján.

FAT32 fájlszerkezet

A FAT32 rendszer külső memóriaeszközei nem bájtuk, de blokkolja a címzést. A külső memóriaeszközbe való felvételi adatokat blokkok vagy ágazatok végzik.
A szektor a külső tárolóeszközök minimális címezhető információs tároló egység. Általános szabályként az ágazat mérete fix és 512 bájt. A külső memóriaeszközök címterületének növelése érdekében az ágazatot klaszterek nevű csoportokba keverjük.
Klaszter - több ágazat kombinálása, amely bizonyos tulajdonságokkal rendelkező független egységnek tekinthető. A klaszter fő tulajdonsága az ágazatok vagy bájtok számában mérhető méret.

A FAT32 fájlrendszer a következő struktúrával rendelkezik.
A fájlok rögzítéséhez használt klaszterek számozása 2-vel történik. Általános szabályként a 2-es klaszteret a gyökérkönyvtár használja, és a 3. számú klaszterből származó adatokat tárolják. A gyökérkönyvtár felett bemutatott információk tárolására használt ágazatok nem kombinálódnak a klaszterekké.
A lemezen elfoglalt minimális fájlméret megfelel az 1. fürtnek.
A rendszerindítási szektor a következő információkkal kezdődik:

EB 58 90 - feltétel nélküli átmenet és aláírás;

4D 53 44 4F 53 35 2E 30 msDos5.0;

00 02 - Az ágazatban lévő bájtok száma (általában 512);

1 byte - a klaszter szektorainak száma;

2 bájt - a biztonsági mentési ágazatok száma.

Ezenkívül a rendszerindító szektor a következő fontos információkat tartalmazza:

0x10 (1 byte) - A táblázatok száma (általában 2);

0x20 (4 bytes) - a lemezen lévő ágazatok száma;

0x2c (4 byte) - gyökérkönyvtárszám;

0x47 (11 bytes) - Tom címke;

0x1fe (2 byte) - A rendszerindító szektor aláírása (55 AA).

A fájlrendszer információs szektora:

0x00 (4 byte) - aláírási rendszer (52 52 61 41);

0x1E4 (4 byte) - aláírás (72 72 41 61);

0x1E8 (4 byte) - a szabad klaszterek száma, -1 ha nem ismert;

0x1ec (4 byte) - az utolsó rögzített fürt száma;

0x1fe (2 byte) - aláírás (55 AA).

A zsírasztal tájékoztatást tartalmaz az egyes klaszterek állapotáról a lemezen. A fiatalabb 2 bájt a FAT tábla tárolja F8 FF FF 0F FF FF FF FF (amely megfelel annak a feltételnek a 0. és 1. klaszter, fizikailag hiányzik). Ezután az egyes klaszterek állapota olyan klaszterszámot tartalmaz, amelyben az aktuális fájl vagy a következő információk folytatódnak:

00 00 00 00 - A klaszter ingyenes;

Az FF FF FF 0F az aktuális fájl vége.

8 bájt - fájlnév;

3 bájt - fájlkiterjesztés;

A root könyvtár tartalmaz egy 32 bites információkat az egyes fájlokról, amelyek a következő információkat tartalmaznak:

A hosszú fájlnevekkel való munka esetén (beleértve az orosz neveket is), a fájlnév kódolása az UTF-16 kódolási rendszerben történik. Ebben az egyes szimbólumok kódolását 2 bájt adják. Ebben az esetben a fájl nevét a következő struktúra formájában írják:

1 byte szekvenciák;

10 bájt tartalmazza a fiatalabb 5 fájlnév karaktereket;

1 byte attribútum;

1 byte tartalék;

1 byte - CheckSUM Név DOS;

12 bájt tartalmazza a fiatalabb 3 fájlnév szimbólumát;

2 bájt - az első klaszter száma;

a hosszú név hátralévő szimbólumai.

A SI-ben lévő fájlok működése

A programozó számára a nyílt fájl az olvasható vagy rögzített adatok sorrendjeként jelenik meg. Amikor megnyit egy fájlt azzal, hogy kötődik i / O patak. A megjelenített információk az adatfolyamba vannak írva, a beírt információk olvashatók a patakból.
Ha a szál az I / O-hez nyílik, akkor a standio.h-ben definiált standard fájl típusú struktúrához kötődik. A fájlszerkezet tartalmazza a szükséges fájlinformációkat.
A fájl megnyitása a Fopen () függvény használatával történik, amely a mutatót visszaadja a fájl típusú struktúrájához, amely a későbbi fájl műveletekhez használható.
Fájl * Fopen (név, típus);

név - A nyitott fájl neve (beleértve az útvonalat is),
a típus egy mutató a karaktersorozathoz, amely meghatározza a fájl elérésének módját:
"R" - Nyissa meg az olvasási fájlt (fájlnak léteznie kell);

"W" - Nyisson meg egy üres fájlt a felvételhez; Ha a fájl létezik, tartalma elveszett;

"A" - Nyissa meg a fájlt, hogy írjon a végére (hozzátéve); A fájl létrejön, ha nem létezik;

"R +" - Nyissa meg a fájlt az olvasáshoz és az íráshoz (a fájlnak léteznie kell);

"W +" - Nyisson meg egy üres fájlt az olvasáshoz és az íráshoz; Ha a fájl létezik, tartalma elveszett;

"A +" - Nyisson meg egy fájlt az olvasásra és hozzáadásra, ha a fájl nem létezik, akkor létrejön.

Visszatérési érték - mutató a stream megnyitásához. Ha hibát észlel, null visszaküld.
A fclose () függvény bezárja a vagy áramokban társított nyitott a fopen () fájlok szolgáltatás. A zárt áramot az Fclose () függvény argumentuma határozza meg.
Visszatérési érték: 0 érték, ha a patak sikeresen lezárult; EOF állandó, ha hiba történt.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
#Inlude.
int Main () () (
Fájl * FP;
char name \u003d "my.txt";
ha ((FP \u003d Fopen (név, "r")) \u003d\u003d null)
{
Printf ( "Nem sikerült megnyitni a fájlt");
getchar ();
vissza 0;
}
// megnyitott fájl kezelt
... // az adatokra vonatkozó intézkedések
Fclose (FP);
getchar ();
vissza 0;
}
Olvasási szimbólum a fájlból:
char fgetc (patak);

A funkció argumentum egy mutató a fájlfolyamra. A funkció visszaadja az olvasási szimbólum kódját. Ha elérte a fájl végét, vagy hiba lép fel, az EOF állandó visszakerül.
Írjon szimbólumot a fájlban:
fputc (szimbólum, patak);

A funkció argumentuma a fájlfolyam szimbóluma és mutatója. A funkció visszaadja az olvasási szimbólum kódját.
Az FSCANF () és az FPrintF () funkciók hasonlóak a Scanf () és a Printf () funkciókhoz, de az adatfájlokhoz való munkához, és az első argumentum - mutató a fájlhoz.
fscanf (stream, "FormaterVber", argumentumok);