Jak zapisovat data do textového souboru c. Čtení a zápis souboru. Třída FileStream

Pro programátora je otevřený soubor reprezentován jako sekvence dat, která jsou čtena nebo zapisována. Když je soubor otevřen, je spojen s I/O tok . Výstupní informace se zapisují do proudu, vstupní informace se z proudu čtou.

Když je proud otevřen pro I/O, je spojen se standardní strukturou typu FILE, která je definována v stdio.h. Struktura FILE obsahuje potřebné informace o souboru.

Otevření souboru se provádí pomocí funkce fopen(), která vrací ukazatel na strukturu typu FILE, kterou lze použít pro následné operace se souborem.

SOUBOR *fopen(jméno, typ);

name je název souboru, který se má otevřít (včetně cesty),
typ – ukazatel na řetězec znaků, které definují způsob přístupu k souboru:

· "r" - otevřít soubor pro čtení (soubor musí existovat);

· "w" - otevře prázdný soubor pro zápis; pokud soubor existuje, jeho obsah je ztracen;

· "a" - otevřít soubor pro zápis do konce (pro připojení); soubor je vytvořen, pokud neexistuje;

· "r+" - otevřít soubor pro čtení a zápis (soubor musí existovat);

· "w+" - otevře prázdný soubor pro čtení a zápis; pokud soubor existuje, jeho obsah je ztracen;

· "a+" - otevřít soubor pro čtení a připojení, pokud soubor neexistuje, je vytvořen.

Vrácená hodnota je ukazatel na otevřený stream. Pokud je nalezena chyba, vrátí se NULL.

Funkce fclose() zavře proud nebo proudy spojené se soubory otevřenými pomocí fopen(). Proud, který má být uzavřen, je určen argumentem funkce fclose().

Návratová hodnota: hodnota 0, pokud byl proud úspěšně uzavřen; konstanta EOF, pokud došlo k chybě.

#zahrnout
int main()

char name="my.txt";

if(fp = fopen(jméno, "r")!=NULL)

// bylo možné otevřít soubor?
... // požadované akce s daty

else printf("Nelze otevřít soubor");

Čtení znaku ze souboru:

char fgetc(stream);

Argument funkce je ukazatel na proud typu FILE. Funkce vrací kód čteného znaku. Pokud je dosaženo konce souboru nebo dojde k chybě, je vrácena konstanta EOF.
Zápis znaku do souboru:

fputc(znak, proud);

Argumenty funkce jsou znak a ukazatel na proud typu FILE. Funkce vrací kód čteného znaku.

Funkce fscanf() a fprintf() jsou podobné funkcím scanf() a printf(), ale pracují s datovými soubory a jejich prvním argumentem je ukazatel na soubor.

fscanf(stream, "Vstupni format", argumenty);
fprintf(stream, "Výstupní formát", argumenty);

Funkce fgets() a fputs() jsou pro řetězec I/O, jsou analogické funkcím gets() a puts() pro práci se soubory.

fgets(ukazatel na řetězec, počet znaků, proud);

Znaky se čtou ze streamu, dokud se nepřečte znak nového řádku "\n", který je obsažen v řetězci, nebo dokud není konec streamu EOF nebo byl přečten maximální počet znaků. Výsledek je umístěn do ukazatele řetězce a ukončen znakem null "\0". Funkce vrací adresu řetězce.

fputs(Ukazatel na řetězec, proud);

Zkopíruje řetězec do proudu z aktuální pozice. Ukončovací znak null se nezkopíruje.
Příklad Zadejte číslo a uložte jej do souboru s1.txt. Přečtěte si číslo ze souboru s1.txt, zvyšte ho o 3 a uložte do souboru s2.txt.

Štítky: Textové soubory, fopen, fclose, feof, setbuf, setvbuf, fflush, fgetc, fprintf, fscanf, fgets, stream s vyrovnávací pamětí, stream bez vyrovnávací paměti.

Práce s textovými soubory

Práce s textovým souborem je podobná práci s konzolí: pomocí formátovaných vstupních funkcí ukládáme data do souboru, pomocí formátovaných výstupních funkcí čteme data ze souboru. Existuje mnoho nuancí, které zvážíme později. Hlavní operace, které je třeba provést, jsou

• 1. Otevřete soubor, aby byl přístupný. V souladu s tím můžete otevřít pro čtení, zápis, čtení a zápis, přepisování nebo zápis na konec souboru atd. Když otevřete soubor, může se také stát spousta chyb – soubor nemusí existovat, nemusí to být správný typ souboru, možná nemáte oprávnění se souborem pracovat a tak dále. To vše je třeba vzít v úvahu.
• 2. Přímá práce se souborem – zápis a čtení. Zde je také potřeba pamatovat na to, že nepracujeme s pamětí s náhodným přístupem, ale s bufferovaným streamem, který přidává svá specifika.
• 3. Zavřete soubor. Vzhledem k tomu, že soubor je ve vztahu k programu externím zdrojem, pokud není uzavřen, bude i nadále viset v paměti, možná i po ukončení programu (například nebude možné smazat otevřený soubor nebo vytvořit změny atd.). Někdy je navíc nutné soubor nezavírat, ale „znovu otevřít“, aby se například změnil režim přístupu.

Kromě toho existuje řada úkolů, kdy nepotřebujeme přistupovat k obsahu souboru: přejmenování, přesun, kopírování atd. Bohužel ve standardu C chybí popis funkcí pro tyto potřeby. Určitě existují pro každou z implementací kompilátoru. Čtení obsahu adresáře (složky, adresáře) je také přístup k souboru, protože samotná složka je soubor s metainformacemi.

Někdy je nutné provést některé pomocné operace: přesunout se na požadované místo v souboru, zapamatovat si aktuální pozici, určit délku souboru a podobně.

Pro práci se souborem je vyžadován objekt FILE. Tento objekt uchovává identifikátor toku souboru a informace potřebné k jeho správě, včetně ukazatele na jeho vyrovnávací paměť, indikátoru pozice souboru a indikátorů stavu.

Samotný objekt FILE je struktura, ale k jeho polím by se nemělo přistupovat. Přenosný program musí se souborem zacházet jako s abstraktním objektem, který umožňuje přístup k datovému proudu souborů.

Vytváření a alokace paměti pro objekt typu FILE se provádí pomocí funkcí fopen nebo tmpfile (existují i ​​další, ale my se zaměříme pouze na ně).

Funkce fopen otevře soubor. Vyžaduje dva argumenty – řetězec s adresou souboru a řetězec s režimem přístupu k souboru. Název souboru může být absolutní nebo relativní. fopen vrací ukazatel na objekt FILE, který pak lze použít k přístupu k souboru.

FILE* fopen(const char* název souboru, režim const char*);

Například otevřeme soubor a napíšeme do něj Hello World

#zahrnout #zahrnout #zahrnout void main() ( //Pomocí proměnné file přistoupíme k souboru FILE *file; //Otevřete textový soubor s oprávněním k zápisu file = fopen("C:/c/test.txt", "w+t" ); //Zapište do souboru fprintf(soubor, "Ahoj světe!"); //Zavřete soubor fclose(file); getch(); )

Samotná funkce fopen alokuje paměť pro objekt, čištění se provádí funkcí fclose. Soubor musíte zavřít, sám se nezavře.

Funkce fopen může otevřít soubor v textovém nebo binárním režimu. Výchozí nastavení je text. Režim přístupu může být následující

Pokud potřebujete otevřít soubor v binárním režimu, pak se na konec řádku přidá písmeno b, například „rb“, „wb“, „ab“, nebo pro smíšený režim „ab+“, „wb+ ““, „ab+“. Místo b můžete přidat písmeno t, pak se soubor otevře v textovém režimu. Záleží na provedení. V novém standardu C (2011) písmeno x znamená, že funkce fopen by měla selhat, pokud soubor již existuje. Doplňme náš starý program: znovu otevřete soubor a zvažte, že jsme ho tam napsali.

#zahrnout #zahrnout #zahrnout void main() ( SOUBOR *soubor; vyrovnávací paměť znaků; soubor = fopen("C:/c/test.txt", "w"); fprintf(soubor, "Ahoj světe!"); fclose(soubor); soubor = fopen("C:/c/test.txt", "r"); fgets(vyrovnávací paměť, 127, soubor); printf("%s", vyrovnávací paměť); fclose(soubor); getch(); )

Můžete použít fscanf místo fgets, ale pamatujte, že může číst pouze řetězec do první mezery.
fscanf(soubor, "%127s", vyrovnávací paměť);

Také místo otevírání a zavírání souboru můžete použít funkci freeopen, která soubor „znovu otevře“ s novými oprávněními.

#zahrnout #zahrnout #zahrnout void main() ( SOUBOR *soubor; vyrovnávací paměť znaků; soubor = fopen("C:/c/test.txt", "w"); fprintf(soubor, "Ahoj světe!"); freopen("C:/ c/test.txt", "r", soubor); fgets(vyrovnávací paměť, 127, soubor); printf("%s", vyrovnávací paměť); fclose(soubor); getch(); )

Funkce fprintf a fscanf se od printf a scanf liší pouze tím, že jako první argument berou ukazatel na SOUBOR, do kterého budou vystupovat nebo ze kterého budou číst data. Zde je vhodné hned dodat, že funkce printf a scanf lze snadno nahradit funkcemi fprintf a fscanf. V OS (považujeme za nejběžnější a adekvátní operační systémy) existují tři standardní toky: standardní výstupní stdout, standardní vstupní stdin a standardní chybový stderr. Automaticky se otevírají při spouštění aplikace a jsou přidruženy ke konzole. Příklad

#zahrnout #zahrnout #zahrnout void main() ( int a, b; fprintf(stdout, "Zadejte dvě čísla\n"); fscanf(stdin, "%d", &a); fscanf(stdin, "%d", &b); if (b == 0) ( fprintf(stderr, "Chyba: dělit nulou"); ) else ( fprintf(stdout, "%.3f", (float) a / (float) b); ) getch(); )

Chyba při otevírání souboru

Pokud selže volání funkce fopen, vrátí hodnotu NULL. Chyby při práci se soubory jsou poměrně časté, takže při každém otevření souboru musíme zkontrolovat výsledek práce

#zahrnout #zahrnout #zahrnout #define ERROR_OPEN_FILE -3 void main() ( FILE *soubor; vyrovnávací paměť znaků; soubor = fopen("C:/c/test.txt", "w"); if (soubor == NULL) ( printf("Chyba při otevírání soubor"); getch(); exit(ERROR_OPEN_FILE); ) fprintf(soubor, "Ahoj světe!"); freopen("C:/c/test.txt", "r", soubor); if (soubor = = NULL) ( printf("Chyba při otevírání souboru"); getch(); exit(ERROR_OPEN_FILE); ) fgets(buffer, 127, soubor); printf("%s", buffer); fclose(soubor); getch() ;)

Problém je způsoben případem, kdy je otevřeno několik souborů najednou: pokud nelze otevřít jeden z nich, musí být zavřeny i ostatní

SOUBOR *vstupniSoubor, *výstupníSoubor; bez znaménka m, n; bez znaménka i, j; inputFile = fopen(INPUT_FILE, READ_ONLY); if (vstupniSoubor == NULL) ( printf("Chyba pri otevírání souboru %s", INPUT_FILE); getch(); exit(3); ) outputFile = fopen(VYSTUPNÍ_SOUBOR, POUZE ZAPIS); if (outputFile == NULL) ( printf("Chyba při otevírání souboru %s", OUTPUT_FILE); getch(); if (vstupníSoubor != NULL) ( fclose(vstupníSoubor); ) exit(4); ) ...

V jednoduchých případech můžete jednat na straně, jako v předchozí části kódu. Ve složitějších případech se používají metody, které nahrazují RAII z ​​C ++: wrappery, nebo funkce kompilátoru (vyčištění v GCC) atp.

Ukládání dat do vyrovnávací paměti

Jak již bylo zmíněno dříve, když vydáváme data, jsou nejprve uložena do vyrovnávací paměti. Vyrovnávací paměť je vymazána

• 1) Pokud je plná
• 2) Pokud se stream uzavře
• 3) Pokud výslovně označíme, že je nutné vymazat buffer (i zde jsou výjimky :)).
• 4) Vymazáno také, pokud byl program úspěšně dokončen. Současně jsou všechny soubory uzavřeny. V případě chyby za běhu se to nemusí stát.

Uvolnění vyrovnávací paměti můžete vynutit voláním funkce fflush(File *). Zvažte dva příklady - s čištěním a bez.

#zahrnout #zahrnout #zahrnout void main() ( FILE *soubor; char c; soubor = fopen("C:/c/test.txt", "w"); do ( c = getch(); fprintf(soubor, "%c", c ); fprintf(stdout, "%c", c); //fflush(soubor); ) while(c != "q"); fclose(soubor); getch(); )

Odkomentujte výzvu k fflush. Za běhu otevřete textový soubor a podívejte se na chování.

Vyrovnávací paměť souboru můžete přiřadit sami nastavením vlastní velikosti. To se provádí pomocí funkce

void setbuf(FILE*stream, char*buffer);

který vezme již otevřený SOUBOR a ukazatel na nový buffer. Velikost nové vyrovnávací paměti musí být alespoň BUFSIZ (například na aktuální pracovní stanici je BUFSIZ 512 bajtů). Pokud předáte hodnotu NULL jako vyrovnávací paměť, stream bude bez vyrovnávací paměti. Funkci můžete také použít

int setvbuf(SOUBOR*stream, znak*vyrovnávací paměť, režim int, velikost_t);

který bere vyrovnávací paměť libovolné velikosti. režim může nabývat následujících hodnot

• _IOFBF- plné ukládání do vyrovnávací paměti. Data jsou zapsána do souboru, když je plný. Při čtení je vyrovnávací paměť považována za plnou, když je požadována vstupní operace a vyrovnávací paměť je prázdná.
• _IOLBF- lineární vyrovnávací paměť. Data se zapisují do souboru, když se zaplní nebo když je nalezen znak nového řádku. Při čtení se vyrovnávací paměť naplní znakem nového řádku, když je požadována vstupní operace a vyrovnávací paměť je prázdná.
• _IONBF- žádné ukládání do vyrovnávací paměti. V tomto případě jsou parametry velikosti a vyrovnávací paměti ignorovány.

Příklad: nastavíme si vlastní vyrovnávací paměť a uvidíme, jak probíhá čtení ze souboru. Nechť je soubor krátký (něco jako Hello, World!) a čteme jej znak po znaku

#zahrnout #zahrnout #zahrnout void main() ( FILE *input = NULL; char c; char buffer = (0); input = fopen("D:/c/text.txt", "rt"); setbuf(vstup, buffer); while ( !feof(vstup)) ( c = fgetc(vstup); printf("%c\n", c); printf("%s\n", buffer); _getch(); ) fclose(vstup); )

Je vidět, že data jsou již ve vyrovnávací paměti. Čtení znak po znaku se již provádí z vyrovnávací paměti.

feof

funkce int feof(FILE*stream); vrátí true, pokud byl dosažen konec souboru. Funkci je vhodné použít, když potřebujete projít celý soubor od začátku do konce. Nechť existuje soubor s textovým obsahem text.txt. Přečteme soubor znak po znaku a zobrazíme jej na obrazovce.

#zahrnout #zahrnout #zahrnout void main() ( FILE *input = NULL; char c; input = fopen("D:/c/text.txt", "rt"); if (vstup == NULL) ( printf("Chyba při otevírání souboru") ; _getch(); exit(0); ) while (!feof(vstup)) ( c = fgetc(vstup); fprintf(stdout, "%c", c); ) fclose(vstup); _getch(); )

Vše by bylo v pořádku, jen funkce feof nefunguje správně ... Je to způsobeno tím, že pojem "konec souboru" není definován. Při použití feof dochází k běžné chybě, když se poslední přečtená data vytisknou dvakrát. To je způsobeno skutečností, že data jsou zapsána do vstupní vyrovnávací paměti, poslední čtení proběhne s chybou a funkce vrátí starou načtenou hodnotu.

#zahrnout #zahrnout #zahrnout void main() ( FILE *input = NULL; char c; input = fopen("D:/c/text.txt", "rt"); if (vstup == NULL) ( printf("Chyba při otevírání souboru") ; _getch(); exit(0); ) while (!feof(vstup)) ( fscanf(vstup, "%c", &c); fprintf(stdout, "%c", c); ) fclose(vstup); _getch(); )

Tento příklad selže (s největší pravděpodobností) a vytiskne poslední znak souboru dvakrát.

Řešením je nepoužívat feof. Například uložit celkový počet záznamů nebo využít toho, že funkce fscanf apod. obvykle vracejí počet správně přečtených a spárovaných hodnot.

#zahrnout #zahrnout #zahrnout void main() ( FILE *input = NULL; char c; input = fopen("D:/c/text.txt", "rt"); if (vstup == NULL) ( printf("Chyba při otevírání souboru") ; _getch(); exit(0); ) while (fscanf(vstup, "%c", &c) == 1) ( fprintf(stdout, "%c", c); ) fclose(vstup); _getch() ;)

Příklady

1. V jednom souboru jsou zapsána dvě čísla - rozměry pole. Vyplňme druhý soubor polem náhodných čísel.

#zahrnout #zahrnout #zahrnout #zahrnout //Názvy souborů a oprávnění #define INPUT_FILE "D:/c/input.txt" #define OUTPUT_FILE "D:/c/output.txt" #define READ_ONLY "r" #define WRITE_ONLY "w" //Maximální hodnota pro pole velikost #define MAX_DIMENSION 100 //Chyba při otevírání souboru #define ERROR_OPEN_FILE -3 void main() ( SOUBOR *vstupni_soubor, *vystupni_soubor; bez znaménka m, n; bez znaménka i, j; inputFile = fopen(INPUT_FILE, READ_ONLY); if ( inputFile = = NULL) ( printf("Chyba při otevírání souboru %s", INPUT_FILE); getch(); exit(ERROR_OPEN_FILE); ) outputFile = fopen(OUTPUT_FILE, WRITE_ONLY); if (outputFile == NULL) ( printf("Chyba při otevírání souboru %s", OUTPUT_FILE); getch(); //Pokud byl soubor úspěšně otevřen pro čtení, musí být uzavřen if (vstupníSoubor != NULL) ( fclose(vstupníSoubor); ) exit(ERROR_OPEN_FILE); ) fscanf(vstupníSoubor , "%ud %ud", &m, &n); if (m > MAX_DIMENSION) ( m = MAX_DIMENSION; ) if (n > MAX_DIMENSION) ( n = MAX_DIMENSION; ) srand(time(NULL)); for (i = 0 i< n; i++) { for (j = 0; j < m; j++) { fprintf(outputFile, "%8d ", rand()); } fprintf(outputFile, "\n"); } //Закрываем файлы fclose(inputFile); fclose(outputFile); }

2. Uživatel zkopíruje soubor, přičemž nejprve zvolí provozní režim: soubor lze odeslat do konzole i zkopírovat do nového souboru.

#zahrnout #zahrnout #zahrnout #define ERROR_FILE_OPEN -3 void main() ( SOUBOR *původ = NULL; SOUBOR *výstup = NULL; název souboru char; režim int; printf("Zadejte název souboru: "); scanf("%1023s", název souboru); původ = fopen (název souboru, "r"); if (původ == NULL) ( printf("Chyba při otevírání souboru %s", název souboru); getch(); exit(ERROR_FILE_OPEN); ) printf("vstup do režimu: "); scanf( "%d", &režim); if (režim == 1) ( printf("Zadejte název souboru: "); scanf("%1023s", název souboru); výstup = fopen(název souboru, "w"); if (výstup = = NULL) ( printf("Chyba při otevírání souboru %s", název souboru); getch(); fclose(origin); exit(ERROR_FILE_OPEN); ) ) else ( output = stdout; ) while (!feof(origin)) ( fprintf (výstup, "%c", fgetc(origin)); ) fclose(origin); fclose(output); getch(); )

3. Uživatel zadá data z konzole a zapisují se do souboru, dokud nestiskne klávesu esc. Podívejte se na program a uvidíte. jak se chová, když napíšete backspace: co je výstupem do souboru a co výstupem do konzole.

#zahrnout #zahrnout #zahrnout #define ERROR_FILE_OPEN -3 void main() ( FILE *výstup = NULL; znak c; výstup = fopen("D:/c/test_output.txt", "w+t"); if (výstup == NULL) ( printf ("Chyba při otevírání souboru"); _getch(); exit(ERROR_FILE_OPEN); ) for (;;) ( c = _getch(); if (c == 27) ( break; ) fputc(c, výstup); fputc( c, stdout); ) fclose(výstup); )

4. Soubor obsahuje celá čísla. Najděte jich maximum. Využijme toho, že funkce fscanf vrací počet správně přečtených a spárovaných objektů. Číslo 1 by mělo být vráceno pokaždé.

#zahrnout #zahrnout #zahrnout #define ERROR_FILE_OPEN -3 void main() ( FILE *vstup = NULL; int num, maxn, hasRead; input = fopen("D:/c/input.txt", "r"); if (vstup == NULL) ( printf("Chyba při otevírání souboru"); _getch(); exit(ERROR_FILE_OPEN); ) maxn = INT_MIN; hasRead = 1; while (hasRead == 1) ( hasRead = fscanf(vstup, "%d", &num); if (hasRead != 1) ( pokračovat; ) if (num >

Dalším řešením je číst čísla, dokud se nedostaneme na konec souboru.

#zahrnout #zahrnout #zahrnout #zahrnout #define ERROR_FILE_OPEN -3 void main() ( FILE *vstup = NULL; int num, maxn, hasRead; input = fopen("D:/c/input.txt", "r"); if (vstup == NULL) ( printf("Chyba při otevírání souboru"); _getch(); exit(ERROR_FILE_OPEN); ) maxn = INT_MIN; while (!feof(vstup)) ( fscanf(vstup, "%d", &num); if (číslo > maxn ) ( maxn = num; ) ) printf("max počet = %d", maxn); fclose(input); _getch(); )

5. Soubor obsahuje slova: ruské slovo, tabulka, anglické slovo, v několika řádcích. Uživatel zadá anglické slovo, je nutné zobrazit ruské.

Překladový soubor vypadá asi takto

slunce slunce
tužkové pero
kuličkové pero tužka
dveře dveří
okna okna
židle
křeslo

a uloženy v kódování cp866 (OEM 866). Zde je důležité: poslední dvojice slov také končí novým řádkem.

Algoritmus je následující - načteme řádek ze souboru, najdeme v řádku tabulátor, nahradíme tabulátor nulou, zkopírujeme ruské slovo z vyrovnávací paměti, zkopírujeme anglické slovo z vyrovnávací paměti, zkontrolujeme rovnost.

#zahrnout #zahrnout #zahrnout #zahrnout #define ERROR_FILE_OPEN -3 void main() ( FILE *input = NULL; char buffer; char enWord; char ruWord; char usrWord; unsigned index; int length; int wasFound; input = fopen("D:/c/input.txt ", "r"); if (vstup == NULL) ( printf("Chyba při otevírání souboru"); _getch(); exit(ERROR_FILE_OPEN); ) printf("zadejte slovo: "); fgets(usrWord, 127, stdin ); wasFound = 0; while (!feof(input)) ( fgets(buffer, 511, input); length = strlen(buffer); for (index = 0; index< length; index++) { if (buffer == "\t") { buffer = "\0"; break; } } strcpy(ruWord, buffer); strcpy(enWord, &buffer); if (!strcmp(enWord, usrWord)) { wasFound = 1; break; } } if (wasFound) { printf("%s", ruWord); } else { printf("Word not found"); } fclose(input); _getch(); }

6. Spočítejte počet řádků v souboru. Budeme číst soubor znak po znaku a počítat počet znaků "\n", dokud nenarazíme na znak EOF. EOF je speciální znak, který označuje, že vstup skončil a nejsou k dispozici žádná další data ke čtení. Funkce vrací zápornou hodnotu při chybě.
POZNÁMKA: EOF je typu int, takže ke čtení znaků musíte použít int. Také hodnota EOF není standardem definována.

#define _CRT_SECURE_NO_WARNINGS #include #zahrnout #zahrnout int cntLines(const char *název souboru) ( int řádky = 0; int libovolný; //jakýkoli typu int, protože EOF je typu int! FILE *f = fopen(název souboru, "r"); if (f == NULL) ( return -1; ) do ( any = fgetc(f); //printf("%c", any);//debug if (any == "\n") ( lines++; ) ) while(any != EOF); ​​​​fclose(f); návratové řádky; ) void main() ( printf("%d\n", cntLines("C:/c/file.txt")); _getch(); )

Výukový program Ru-Cyrl 18 Sypačov S.S. 1989-04-14 [e-mail chráněný]Štěpán Sypačov studentů

Stále to není jasné? - otázky pište do rámečku

Většina počítačových programů pracuje se soubory, a proto je potřeba soubory vytvářet, mazat, zapisovat, číst, otevírat. Co je soubor? Soubor je pojmenovaná kolekce bajtů, která může být uložena na nějakém úložném zařízení. No, teď je jasné, že soubor je nějaká posloupnost bajtů, která má svůj vlastní jedinečný název, například soubor .txt. Soubory se stejným názvem nemohou být ve stejném adresáři. Název souboru je chápán nejen jako jeho název, ale také jako přípona, například: soubor.txt a soubor.dat — různé soubory, i když mají stejný název. Existuje něco jako úplný název souborů - jedná se o úplnou adresu do adresáře souboru s názvem souboru, například: D:\docs\file.txt . Je důležité porozumět těmto základním pojmům, jinak bude obtížné pracovat se soubory.

Chcete-li pracovat se soubory, musíte zahrnout soubor záhlaví . V několik definovaných tříd a hlavičkových souborů — vstup do souboru a — výstup souboru.

File I/O je podobný standardnímu I/O, jediný rozdíl je v tom, že I/O se neprovádí na obrazovku, ale do souboru. Pokud je vstup/výstup na standardní zařízení prováděn pomocí objektů cin a cout, pak pro organizaci souborových I/O stačí vytvořit vlastní objekty, které lze použít podobně jako operátory cin a cout.

Například je potřeba vytvořit textový soubor a do něj napsat řádek Práce se soubory v C++. Chcete-li to provést, musíte provést následující kroky:

1. vytvořit objekt třídy proudu ;
2. asociovat objekt třídy se souborem, do kterého se má zapisovat;
3. zapsat řádek do souboru;
4. zavřete soubor.

Proč je nutné vytvořit objekt třídy ofstream a ne třídy ifstream? Protože potřebujete zapisovat do souboru a pokud byste potřebovali číst data ze souboru, pak by se vytvořil objekt třídy ifstream.

// vytvořte objekt pro zápis do souboru ofstream /*jméno objektu*/; // objekt třídy proudu

Nazvěme objekt - fout , Zde je to, co se stane:

Ofstream fout;

Proč potřebujeme předmět? Objekt musí být schopen zapisovat do souboru. Objekt již byl vytvořen, ale není přidružen k souboru, do kterého má být řetězec zapsán.

fout.open("cppstudio.txt"); // asociovat objekt se souborem

Prostřednictvím operace tečka získáme přístup k metodě třídy open(), v jejíž závorce uvedeme název souboru. Zadaný soubor bude vytvořen v aktuálním adresáři s programem. Pokud existuje soubor se stejným názvem, stávající soubor bude nahrazen novým. Soubor je tedy otevřený, zbývá do něj napsat požadovaný řádek. Dělá se to takto:

Fout<< "Работа с файлами в С++"; // запись строки в файл

Pomocí operace cast to stream ve spojení s objektem fout je řetězec File Handling v C++ zapsán do souboru. Protože již není nutné měnit obsah souboru, musí být uzavřen, to znamená, že objekt by měl být oddělen od souboru.

fout.close(); // zavřete soubor

V důsledku toho byl vytvořen soubor s řádkem Práce se soubory v C++.

Kroky 1 a 2 lze kombinovat, to znamená v jednom řádku vytvořit objekt a přiřadit jej k souboru. Dělá se to takto:

Ofstream fout("cppstudio.txt"); // vytvoří objekt třídy ofstream a přiřadí jej k souboru cppstudio.txt

Zkombinujme celý kód a získáme následující program.

// soubor.cpp: definuje vstupní bod pro konzolovou aplikaci. #include "stdafx.h" #include pomocí jmenného prostoru std; int main(int argc, char* argv) ( ofstream fout("cppstudio.txt"); // vytvořte objekt třídy ofstream pro zápis a přidružte jej k souboru cppstudio.txt fout<< "Работа с файлами в С++"; // запись строки в файл fout.close(); // закрываем файл system("pause"); return 0; }

Zbývá zkontrolovat správnou činnost programu, a proto soubor otevřeme cppstudio.txt a podívejte se na jeho obsah, mělo by to být - Práce se soubory v C++.

1. vytvořit objekt třídy ifstream a přiřadit jej k souboru, ze kterého se má číst;
2. číst soubor;
3. zavřete soubor.

#zahrnout pomocí jmenného prostoru std; int main(int argc, char* argv) ( setlocale(LC_ALL, "rus"); // správné zobrazení char buff v azbuce; ​​// mezipaměť pro ukládání textu načteného ze souboru ifstream fin("cppstudio.txt "); // otevření souboru pro čtení fin >><< buff << endl; // напечатали это слово fin.getline(buff, 50); // считали строку из файла fin.close(); // закрываем файл cout << buff << endl; // напечатали эту строку system("pause"); return 0; }

Program ukazuje dva způsoby čtení ze souboru, prvním je použití operace přenosu do streamu, druhým je použití funkce getline() . V prvním případě se přečte pouze první slovo a ve druhém případě se přečte řetězec 50 znaků. Ale protože v souboru zbývá méně než 50 znaků, znaky se přečtou až do posledního včetně. Všimněte si, že čtení podruhé (řádek 17) pokračoval po prvním slově, a ne od začátku, protože první slovo bylo přečtenořádek 14. Výsledek programu je na obrázku 1.

Práce se soubory v C++ Pokračujte stisknutím libovolné klávesy. . .

Obrázek 1 - Práce se soubory v C++

Program fungoval správně, ale není tomu tak vždy, i když je vše v pořádku s kódem. Programu byl například předán název neexistujícího souboru nebo došlo k chybě v názvu. Co pak? V tomto případě se nestane vůbec nic. Soubor nebude nalezen, což znamená, že jej nelze přečíst. Proto bude kompilátor ignorovat řádky, kde je soubor zpracováván. V důsledku toho se program správně ukončí, ale na obrazovce se nic nezobrazí. Zdálo by se, že jde o zcela normální reakci na takovou situaci. Prostý uživatel však nepochopí, o co jde a proč se na obrazovce neobjevil řádek ze souboru. Aby bylo vše velmi jasné, C++ poskytuje takovou funkci - is_open() , která vrací celočíselné hodnoty: 1 - pokud byl soubor úspěšně otevřen, 0 - pokud soubor nebyl otevřen. Dokončíme program otevřením souboru tak, že pokud se soubor neotevře, zobrazí se odpovídající zpráva.

// file_read.cpp: definuje vstupní bod pro konzolovou aplikaci. #include "stdafx.h" #include #zahrnout pomocí jmenného prostoru std; int main(int argc, char* argv) ( setlocale(LC_ALL, "rus"); // správné zobrazení cyrilického znakového buffu; // přechodná vyrovnávací paměť pro text načtený ze souboru ifstream fin("cppstudio.doc"); / / ( ZADAL NESPRÁVNÝ NÁZEV SOUBORU) if (!fin.is_open()) // pokud soubor není otevřený cout<< "Файл не может быть открыт!\n"; // сообщить об этом else { fin >> buff; // přečtení prvního slova ze souboru cout<< buff << endl; // напечатали это слово fin.getline(buff, 50); // считали строку из файла fin.close(); // закрываем файл cout << buff << endl; // напечатали эту строку } system("pause"); return 0; }

Výsledek programu je na obrázku 2.

Soubor nelze otevřít! Pokračujte stiskem libovolné klávesy. . .

Obrázek 2 - Práce se soubory v C++

Jak můžete vidět na obrázku 2, program hlásil, že soubor nelze otevřít. Pokud tedy program pracuje se soubory, doporučuje se použít tuto funkci is_open() , i když jste si jisti, že soubor existuje.

Režimy otevírání souborů

Režimy otevírání souborů určují způsob použití souborů. Pro nastavení režimu poskytuje třída ios_base konstanty, které určují režim otevírání souboru (viz Tabulka 1).

Režimy otevírání souborů lze nastavit přímo při vytváření objektu nebo při volání funkce open(). .

Ofstream fout("cppstudio.txt", ios_base::app); // otevření souboru pro přidání informací na konec souboru fout. open("cppstudio.txt", ios_base::app); // otevřete soubor pro přidání informací na konec souboru

Režimy otevření souboru lze kombinovat pomocí bitové booleovské operace nebo| , například: ios_base::out | ios_base::trunc - otevřete soubor pro zápis po jeho vymazání.

Objekty třídy ofstream , jsou-li spojeny se soubory, standardně obsahují režimy otevírání souborů ios_base::out | ios_base::trunc . To znamená, že soubor bude vytvořen, pokud neexistuje. Pokud soubor existuje, jeho obsah bude smazán a samotný soubor bude připraven k nahrávání. Objekty třídy ifstream, jsou-li spojeny se souborem, mají ve výchozím nastavení režim otevírání souboru ios_base::in - soubor je otevřen pouze pro čtení. Režimu otevírání souborů se také říká příznak, kvůli čitelnosti budeme tento termín v budoucnu používat. Tabulka 1 neuvádí všechny příznaky, ale pro začátek by vám měly stačit.

Vezměte prosím na vědomí, že příznaky ate a app jsou velmi podobné v popisu, oba přesouvají ukazatel na konec souboru, ale příznak aplikace umožňuje zápis pouze na konec souboru a příznak ate jednoduše přeuspořádá příznak na konec souboru a neomezuje prostor pro nahrávání.

Pojďme vyvinout program, který pomocí operace sizeof() vypočítá charakteristiky hlavních datových typů v C++ a zapíše je do souboru. Vlastnosti:

1. počet bajtů přidělených pro datový typ
2. maximální hodnota, kterou může konkrétní datový typ uložit.

Zápis do souboru musí být v následujícím formátu:

/* datový typ byte max. hodnota bool = 1 255,00 char = 1 255,00 short int = 2 32767,00 unsigned short int = 2 65535,00 int = 4 2147483647,00 unsigned int = 4 670629,00 unsigned int = 4 670629,00 7,00 unsigned long int = 4 4294967295,00 float = 4 2147483647,00 dlouhý plovák = 8 9223372036854775800,00 dvojitý = 8 9223372036854775800,00 */

Takový program již byl vyvinut dříve v této části, ale tam byly všechny informace o datových typech vyvedeny na standardní výstupní zařízení a my musíme program předělat tak, aby se informace zapisovaly do souboru. Chcete-li to provést, musíte soubor otevřít v režimu zápisu s předběžným zkrácením informací o aktuálním souboru ( řádek 14). Jakmile je soubor vytvořen a úspěšně otevřen (řádky 16 - 20), místo příkazu cout v řádek 22 použijte objekt fout. tedy místo obrazovky budou informace o datových typech zapsány do souboru.

// write_file.cpp: definuje vstupní bod pro konzolovou aplikaci. #include "stdafx.h" #include #zahrnout // práce se soubory #include // I/O manipulátory používající jmenný prostor std; int main(int argc, char* argv) ( setlocale(LC_ALL, "rus"); // propojí objekt se souborem, přičemž soubor otevírá v režimu zápisu a nejprve z něj odstraní všechna data ze streamu fout("data_types.txt ", ios_base::out | ios_base::trunc); if (!fout.is_open()) // pokud soubor nebyl otevřen ( cout<< "Файл не может быть открыт или создан\n"; // напечатать соответствующее сообщение return 1; // выполнить выход из программы } fout << " data type " << "byte" << " " << " max value "<< endl // záhlaví sloupců <<"bool = " << sizeof(bool) << " " << fixed << setprecision(2) /*вычисляем максимальное значение для типа данных bool*/ << (pow(2,sizeof(bool) * 8.0) - 1) << endl << "char = " << sizeof(char) << " " << fixed << setprecision(2) /*вычисляем максимальное значение для типа данных char*/ << (pow(2,sizeof(char) * 8.0) - 1) << endl << "short int = " << sizeof(short int) << " " << fixed << setprecision(2) /*вычисляем максимальное значение для типа данных short int*/ << (pow(2,sizeof(short int) * 8.0 - 1) - 1) << endl << "unsigned short int = " << sizeof(unsigned short int) << " " << fixed << setprecision(2) /*вычисляем максимальное значение для типа данных unsigned short int*/ << (pow(2,sizeof(unsigned short int) * 8.0) - 1) << endl << "int = " << sizeof(int) << " " << fixed << setprecision(2) /*вычисляем максимальное значение для типа данных int*/ << (pow(2,sizeof(int) * 8.0 - 1) - 1) << endl << "unsigned int = " << sizeof(unsigned int) << " " << fixed << setprecision(2) /*вычисляем максимальное значение для типа данных unsigned int*/ << (pow(2,sizeof(unsigned int) * 8.0) - 1) << endl << "long int = " << sizeof(long int) << " " << fixed << setprecision(2) /*вычисляем максимальное значение для типа данных long int*/ << (pow(2,sizeof(long int) * 8.0 - 1) - 1) << endl << "unsigned long int = " << sizeof(unsigned long int) << " " << fixed << setprecision(2) /*вычисляем максимальное значение для типа данных undigned long int*/ << (pow(2,sizeof(unsigned long int) * 8.0) - 1) << endl << "float = " << sizeof(float) << " " << fixed << setprecision(2) /*вычисляем максимальное значение для типа данных float*/ << (pow(2,sizeof(float) * 8.0 - 1) - 1) << endl << "long float = " << sizeof(long float) << " " << fixed << setprecision(2) /*вычисляем максимальное значение для типа данных long float*/ << (pow(2,sizeof(long float) * 8.0 - 1) - 1) << endl << "double = " << sizeof(double) << " " << fixed << setprecision(2) /*вычисляем максимальное значение для типа данных double*/ << (pow(2,sizeof(double) * 8.0 - 1) - 1) << endl; fout.close(); // программа больше не использует файл, поэтому его нужно закрыть cout << "Данные успешно записаны в файл data_types.txt\n"; system("pause"); return 0; }

Není možné si nevšimnout, že změny v programu jsou minimální a to vše díky tomu, že standardní vstup/výstup a souborový vstup/výstup jsou využívány naprosto stejně. Na konci programuřádek 45soubor jsme výslovně uzavřeli, ačkoli to není vyžadováno, považuje se to za dobrou programátorskou praxi. Stojí za zmínku, že všechny funkce a manipulátory používané pro formátování standardního vstupu/výstupu jsou relevantní i pro vstup/výstup souboru. Při obsluze tedy nedošlo k žádným chybám cout byl nahrazen předmětem fout.

Pro snadnou manipulaci jsou informace v úložných zařízeních ukládány ve formě souborů.

Soubor je pojmenovaná oblast externí paměti alokovaná pro ukládání pole dat. Data obsažená v souborech jsou nejrozmanitější povahy: programy v algoritmickém nebo strojovém jazyce; počáteční data pro provoz programů nebo výsledky provádění programu; libovolné texty; grafika atd.

Adresář (složka, adresář) - pojmenovaná kolekce bajtů na paměťovém médiu obsahující názvy podadresářů a souborů, používaná v souborovém systému pro zjednodušení organizace souborů.

souborový systém je funkční část operačního systému, která zajišťuje operace se soubory. Příklady souborových systémů jsou FAT (FAT - File Allocation Table, souborová alokační tabulka), NTFS, UDF (používané na CD).

Existují tři hlavní verze FAT: FAT12, FAT16 a FAT32. Liší se bitovostí záznamů ve struktuře disku, tzn. počet bitů přidělených pro uložení čísla clusteru. FAT12 se používá především pro diskety (do 4 KB), FAT16 pro malé disky, FAT32 pro velkokapacitní FLASH mechaniky (do 32 GB).

Zvažte strukturu systému souborů pomocí FAT32 jako příklad.

Struktura souborů FAT32

Externí paměťová zařízení v systému FAT32 nemají bajtové, ale blokové adresování. Informace se zapisují na externí paměťové zařízení v blocích nebo sektorech.

Sektor – minimální adresovatelná jednotka úložiště informací na externích paměťových zařízeních. Velikost sektoru je obvykle pevně nastavena na 512 bajtů. Pro zvětšení adresového prostoru externích paměťových zařízení jsou sektory kombinovány do skupin nazývaných clustery.

Klastr je sdružení několika sektorů, které lze považovat za samostatnou jednotku s určitými vlastnostmi. Hlavní vlastností clusteru je jeho velikost, měřená počtem sektorů nebo počtem bajtů.

Systém souborů FAT32 má následující strukturu.

Clustery používané pro zápis souborů jsou číslovány od 2. Klastr #2 je zpravidla používán kořenovým adresářem a počínaje clusterem #3 se ukládá datové pole. Sektory používané k ukládání informací nad kořenovým adresářem nejsou klastrované.
Minimální velikost souboru na disku je 1 cluster.

Spouštěcí sektor začíná následujícími informacemi:

• EB 58 90 - nepodmíněná větev a podpis;
• 4D 53 44 4F 53 35 2E 30 MSDOS5.0;
• 00 02 - počet bajtů v sektoru (obvykle 512);
• 1 byte - počet sektorů v clusteru;
• 2 bajty - počet rezervních sektorů.

Kromě toho spouštěcí sektor obsahuje následující důležité informace:

• 0x10 (1 byte) – počet tabulek FAT (obvykle 2);
• 0x20 (4 bajty) - počet sektorů na disku;
• 0x2C (4 bajty) – číslo clusteru kořenového adresáře;
• 0x47 (11 bajtů) – jmenovka svazku;
• 0x1FE (2 bajty) - Podpis spouštěcího sektoru (55 AA).

Informační sektor souborového systému obsahuje:

• 0x00 (4 bajty) – podpis (52 52 61 41 );
• 0x1E4 (4 bajty) – podpis (72 72 41 61 );
• 0x1E8 (4 bajty) – počet volných clusterů, -1 pokud není znám;
• 0x1EC (4 bajty) – číslo posledního zaznamenaného clusteru;
• 0x1FE (2 bajty) - podpis (55 AA).

Tabulka FAT obsahuje informace o stavu každého clusteru na disku. Spodní 2 bajty tabulky FAT ukládají F8 FF FF 0F FF FF FF FF (odpovídající stavu clusterů 0 a 1, fyzicky nepřítomné). Stav každého clusteru dále obsahuje číslo clusteru, ve kterém aktuální soubor pokračuje, nebo následující informace:

• 00 00 00 00 – cluster je volný;
• FF FF FF 0F je konec aktuálního souboru.

• 8 bajtů - název souboru;
• 3 bajty - přípona souboru;

Kořenový adresář obsahuje sadu 32bitových informačních záznamů pro každý soubor obsahující následující informace:

Při práci s dlouhými názvy souborů (včetně ruských názvů) je název souboru zakódován v kódovacím systému UTF-16. V tomto případě jsou pro kódování každého znaku přiděleny 2 bajty. V tomto případě je název souboru zapsán ve tvaru následující struktury:

• 1 byte sekvence;
• 10 bajtů obsahuje spodních 5 znaků názvu souboru;
• atribut 1 byte;
• 1 bajt vyhrazený;
• 1 byte - kontrolní součet názvu DOS;
• 12 bajtů obsahuje spodní 3 znaky názvu souboru;
• 2 bajty – číslo prvního clusteru;
• zbývající znaky dlouhého jména.

Práce se soubory v C

Pro programátora je otevřený soubor reprezentován jako sekvence dat, která jsou čtena nebo zapisována. Když je soubor otevřen, je spojen s I/O tok. Výstupní informace se zapisují do proudu, vstupní informace se z proudu čtou.

Když je proud otevřen pro I/O, je spojen se standardní strukturou typu FILE , která je definována v stdio.h . Struktura FILE obsahuje potřebné informace o souboru.

Otevření souboru se provádí pomocí funkce fopen(), která vrací ukazatel na strukturu typu FILE , kterou lze použít pro následné operace se souborem.

SOUBOR *fopen(jméno, typ);

name je název souboru, který se má otevřít (včetně cesty),
typ je ukazatel na řetězec znaků, které definují způsob přístupu k souboru:

• "r" - otevřít soubor pro čtení (soubor musí existovat);
• "w" - otevřete prázdný soubor pro zápis; pokud soubor existuje, jeho obsah je ztracen;
• "a" - otevřít soubor pro zápis do konce (pro připojení); soubor je vytvořen, pokud neexistuje;
• "r+" - otevřít soubor pro čtení a zápis (soubor musí existovat);
• "w+" - otevře prázdný soubor pro čtení a zápis; pokud soubor existuje, jeho obsah je ztracen;
• "a+" - otevřít soubor pro čtení a připojení, pokud soubor neexistuje, je vytvořen.

Vrácená hodnota je ukazatel na otevřený stream. Pokud je nalezena chyba, vrátí se NULL.

Funkce fclose() zavře proud nebo proudy spojené se soubory otevřenými pomocí fopen(). Proud, který má být uzavřen, je určen argumentem funkce fclose().

Návratová hodnota: hodnota 0, pokud byl proud úspěšně uzavřen; konstanta EOF, pokud došlo k chybě.

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

#zahrnout
int main() (
SOUBOR *fp;
název znaku = "my.txt" ;
if ((fp = fopen(jméno, "r" )) == NULL )
{
printf( "Nelze otevřít soubor");
getchar();
návrat 0;
}
// otevření souboru bylo úspěšné
... // požadované akce na datech
fclose(fp);
getchar();
návrat 0;
}

Čtení znaku ze souboru:

char fgetc(stream);

Argument funkce je ukazatel na proud typu FILE . Funkce vrací kód čteného znaku. Pokud je dosaženo konce souboru nebo dojde k chybě, je vrácena konstanta EOF.

Zápis znaku do souboru:

fputc(znak, proud);

Argumenty funkce jsou znak a ukazatel na proud typu FILE . Funkce vrací kód čteného znaku.

Funkce fscanf() a fprintf() jsou podobné funkcím scanf() a printf(), ale pracují s datovými soubory a jejich prvním argumentem je ukazatel na soubor.

fscanf(stream, "InputFormat" , args);

Textové soubory

Zvažme práci s textovým souborem v C na příkladu. Vytvořte textový soubor na jednotce C s názvem TextFile.txt. Do tohoto souboru zadejte následující řádky:

Řetězec_1 123 Řetězec_11, 456
Řetězec_2
Řetězec_3

Uložte soubor.

A toto je kód pro program C, který otevře náš soubor a čte z něj řádky:

/* *Autor: @author Subbotin B.P..h> #include #define LEN 50 int main(void) ( puts("Operace s textovými soubory"); char cArray; FILE *pTextFile = fopen("C:\\TextFile.txt", "r"); if(pTextFile == NULL) ( puts("Problems"); return EXIT_FAILURE; ) while(fgets(cArray, LEN, pTextFile) != NULL) ( printf("%s", cArray); ) fclose(pTextFile); return EXIT_SUCCESS; )

Chcete-li otevřít textový soubor v C, použijte funkci fopen:

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

První argument funkce fopen ukazuje na soubor a druhý říká, že soubor je otevřen pro čtení z něj.

Čteme řádky pomocí funkce fgets:

fgets(cArray, LEN, pTextFile);

První argument funkce fgets ukazuje na pole znaků, do kterého budou uloženy přijaté řetězce, druhý argument je maximální počet znaků ke čtení, třetí je náš soubor.

Po dokončení práce se souborem jej musíte zavřít:

fclose(pTextFile);

Dostaneme:

Ruská písmena v řádcích také procházejí.

Mimochodem, tento program jsem vytvořil v Eclipse. Jak pracovat s C/C++ můžete vidět v Eclipse.

Otevřeli jsme tedy a načetli data z textového souboru.

Nyní se naučíme, jak programově vytvořit textový soubor a zapsat do něj data.

/* Autor: @author Subbotin B.P..h> #include int main(void) ( FILE *pTextFile = fopen("C:\\TextFileW.txt", "w"); char *cString = "Toto je řetězec"; char cNewLine = "\n"; int nVal = 123 ; if(pTextFile == NULL) ( puts("Problems"); return EXIT_FAILURE; ) fprintf(pTextFile, "%s%c", cString, cNewLine); fprintf(pTextFile, "%d", nVal); return EXIT_SUCCESS ;)

Vytvořte textový soubor, do kterého chcete zapisovat data:

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

pokud soubor již existuje, bude otevřen a všechna data z něj budou smazána.

C-řetězec cString a číslo nVal jsou programem zapsány do textového souboru. cNewLine je pouze zalomení řádku.

Data zapisujeme do textového souboru pomocí funkce fprintf:

fprintf(pTextFile, "%s%c", cString, cNewLine);

první argument je zde náš soubor, druhý je formátovací řetězec, třetí nebo více je počet argumentů potřebných pro tento formát.