Přečtěte si slovo ze souboru c. Vstup dat ze souboru a výstup do souboru

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.

Š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

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.

1. Práce se soubory v C (funguje i v C++)..

Void main(void)
{
SOUBOR *soubor;
char* název_souboru = "soubor.txt";
charload_string = "žádný";

Soubor = fopen(název_souboru, "w");

Fputs("řetězec", soubor);

Soubor = fopen(název_souboru, "r");
if(soubor != 0)
{
fgets(načíst_řetězec, 50 , soubor);
střih)
jiný
{
střih)
fclose(soubor);
) Popis funkcí práce se soubory je v knihovně stdio.h
Nejprve musíte vytvořit ukazatel na proměnnou typu FILE ( FILE* soubor;).
Otevření souboru se provede voláním funkce fopen ( soubor = fopen(název_souboru, "w");)
První parametr této funkce je název souboru, druhý udává, v jakém režimu se má soubor otevřít. "w"- otevřená pro psaní, "r"- otevřeno pro čtení, "A"- přidávání souborů (toto jsou nejpoužívanější režimy, i když existují i ​​jiné). Zápis a čtení dat ze souboru se provádí pomocí následujících funkcí: fputc, fputs, fgetc, fgets, fprintf, fscanf(Popis těchto funkcí viz stdio.h).
Uzavření souboru se provede voláním funkce fclose ( fclose(soubor);).

Práce se soubory pomocí MFC (třídy CFile, CStdioFile, ...) a standardní MFC třídy CFileDialog.

Třída CF ile

Po vytvoření objektu třídy CFilesoubor můžete otevřít voláním metodyOTEVŘENO. Metoda musí specifikovat cestu k souboru, který má být otevřen, a způsob jeho použití. Prototyp metodyOTEVŘENOmá následující podobu:

Virtual BOOL Open(LPCTSTR lpszFileName, UINT nOpenFlags, CFileException* pError=NULL);

Parametr lpszFileName musí být název souboru, který se má otevřít. Můžete zadat pouze název souboru nebo úplný název souboru, včetně úplné cesty k němu.

Druhý parametr, nOpenFlags, určuje akci, kterou metoda Open se souborem provede, a také atributy souboru. Níže jsou uvedeny některé možné hodnoty parametru nOpenFlags:

• CFile::modeCreate - Vytváří se nový soubor. Pokud zadaný soubor existuje, jeho obsah se vymaže a délka souboru se nastaví na nulu.
• CFile::modeNoTruncate – Tento soubor je určen k použití ve spojení se souborem CFile::modeCreate. Pokud je vytvořen již existující soubor, jeho obsah nebude smazán.

Volitelný parametr pError, což je ukazatel na objekt třídy CFileException, se používá pouze v případě, že by provedení operace se souborem způsobilo chybu. V tomto případě budou další informace zapsány do objektu, na který ukazuje pError.

Metoda OTEVŘENOvrátí nenulovou hodnotu, pokud je soubor otevřený a nulu při chybě. Při otevírání souboru může dojít k chybě, například pokud je v metodě Open pro čtení zadán neexistující soubor.

Třída CFile zahrnuje datový člen m_hFile typu UINT. Ukládá ID otevřeného souboru. Pokud byl objekt třídy CFile již vytvořen, ale soubor ještě nebyl otevřen, pak se do proměnné m_hFile zapíše konstanta hFileNull.

Obvykle se ID otevřeného souboru nepoužívá přímo. Třídní metody CFileumožňují provádět se soubory téměř jakoukoli operaci a nevyžadují zadání identifikátoru souboru. Protože m_hFile je členem třídy, implementace jeho metod k němu má vždy volný přístup.

Po ukončení práce se souborem je nutné jej uzavřít. Třída CFilemá k tomu speciální metodu Close. Je třeba poznamenat, že pokud byl vytvořen objekt třídy CFile a je otevřen soubor a poté je objekt smazán, pak je soubor s ním spojený automaticky uzavřen pomocí destruktoru.

Existuje několik metod třídy pro přístup k souborům. CFile: Číst, číst obrovské, psát, psát obrovské, splachovat. Metody Číst a číst obrovské navržený pro čtení dat z dříve otevřeného souboru. Na 32bitových operačních systémech mohou obě metody současně číst více než 65535 bajtů ze souboru. Specifikace ReadHuge byla zastaralá a je zachována pouze kvůli kompatibilitě s 16bitovými operačními systémy.

Data načtená ze souboru se zapisují do vyrovnávací paměti lpBuf. Parametr nCount určuje počet bajtů ke čtení ze souboru. Ve skutečnosti lze ze souboru přečíst méně bajtů, než požaduje parametr nCount. K tomu dojde, pokud je při čtení dosaženo konce souboru. Metody vrací počet bajtů přečtených ze souboru.

Metody Write a WriteHuge jsou určeny pro zápis do souboru. Na 32bitových operačních systémech mohou obě metody zapsat do souboru více než 65535 bajtů současně. Methods zapíše nCount bajtů z vyrovnávací paměti lpBuf do otevřeného souboru. Pokud dojde k chybě zápisu, jako je například plný disk, metoda vyvolá zpracování výjimek.

Když se k zápisu dat na disk používá metoda Write nebo WriteHuge, může chvíli trvat, než se bude nacházet v dočasné vyrovnávací paměti. Abyste se ujistili, že jsou v souboru na disku provedeny potřebné změny, musíte použít metodu Flush.

Třída zahrnuje metody, které umožňují provádět různé operace se soubory, jako je kopírování, přejmenování, mazání, změna atributů.

Chcete-li změnit název souboru, třída CFile obsahuje statickou metodu PřejmenovatTen plní funkce tohoto příkazu. Metodu nelze použít k přejmenování adresářů. Pokud dojde k chybě, metoda vyvolá výjimku.

Pro mazání souborů ve třídě CFile je zahrnuta statická metoda OdstranitA, která umožňuje smazat zadaný soubor. Tato metoda neumožňuje mazat adresáře. Pokud soubor nelze odstranit, metoda vyvolá výjimku.

Pro určení data a času vytvoření souboru, jeho délky a atributů, statická metoda získat stav. Existují dva druhy metod - první je definována jako virtuální metoda a druhá je definována jako statická metoda.

Virtuální verze metody získat stavdefinuje stav otevřeného souboru přidruženého k tomuto objektu CFile. Tato metoda je volána pouze v případě, že byl vytvořen objekt CFile a soubor je otevřen.

Statická verze metody získat stavumožňuje určit vlastnosti souboru, který není přidružen k objektu třídy CFile. Chcete-li použít tuto metodu, nemusíte soubor nejprve otevírat.

Metody zahrnuté ve třídě rozsah zámku A odemknout rozsah, které vám umožňují uzamknout jeden nebo více datových souborů před přístupem z jiných procesů. Pokud se aplikace pokusí znovu uzamknout data, která byla dříve uzamčena touto nebo jinou aplikací, je vyvolána výjimka. Zámek je jedním z mechanismů, který umožňuje více aplikacím nebo procesům pracovat na stejném souboru současně, aniž by se navzájem rušily.

Pomocí této metody můžete nastavit zámek rozsah zámku. Chcete-li odstranit nainstalované zámky, musíte použít metoduodemknout rozsah. Pokud je v jednom souboru nastaveno několik zámků, musí být každý z nich odstraněn samostatným voláním metodyodemknout rozsah.

Chcete-li přesunout ukazatel aktuální pozice souboru na novou pozici, můžete použít jednu z následujících metod třídy CFile - Seek, SeekToBegin, SeekToEnd. Do třídy CFilezahrnuje také metody, které umožňují nastavit a změnit délku souboru, -GetLength, SetLength.

Chcete-li určit umístění otevřeného souboru na disku, musíte zavolat metodu GetFilePath. Tato metoda vrací objekt třídyCString, který obsahuje úplnou cestu k souboru, včetně názvu jednotky, adresářů, názvu souboru a přípony souboru.

Pokud chcete pouze určit název a příponu otevřeného souboru, můžete použít metodu GetFileName. Vrací objekt CString obsahující název souboru. V případě, že potřebujete zjistit pouze název otevřeného souboru bez přípony, použijte metoduGetFileTitle.

Práce s textovými soubory v C++.

Existují dva hlavní typy souborů: textové a binární. Soubory umožňují uživateli číst velké množství dat přímo z disku, aniž by je musel zadávat z klávesnice.

Text se nazývají soubory skládající se z libovolných znaků. Jsou uspořádány do řádků, z nichž každý končí znakem konce řádku. Samotný konec souboru je označen symbolem "konec souboru". Při zápisu informací do textového souboru, který lze zobrazit pomocí libovolného textového editoru, jsou všechna data převedena do znakového typu a uložena ve znakové podobě.

V binární V souborech se informace čtou a zapisují ve formě bloků určité velikosti, do kterých lze ukládat data libovolného druhu a struktury.

Chcete-li pracovat se soubory, speciální typy dat, volal proudy. Tok ifstream se používá pro práci se soubory v režimu čtení a outstream v režimu nahrávání. Proud se používá pro práci se soubory v režimu zápisu i čtení. fstream.

V programech C++ je při práci s textovými soubory nutné zahrnout knihovny iostream a fstream.

V následujících situacích zapsat data do textového souboru, musíte:

popsat proměnnou typu stream.

výstupní informace do souboru.

nezapomeňte soubor zavřít.

Pro čtení data z textového souboru, musíte:

popsat proměnnou typu ifstream.

otevřít soubor pomocí funkce otevřít.

zavřete soubor.

Záznam informace do textového souboru

Jak již bylo zmíněno dříve, abyste mohli začít pracovat s textovým souborem, musíte deklarovat proměnnou typu ofstream. Například takto:

Vytvoří se proměnná F pro zápis informací do souboru.

Dalším krokem je otevření souboru pro zápis. Obecně bude operátor otevření streamu vypadat takto:

F. otevřít("soubor", režim);

Zde F je proměnná deklarovaná jako ofstream,

soubor - celý název souboru na disku,

režim - režim práce s otevřeným souborem.

Vezměte prosím na vědomí, že při zadávání celého názvu souboru musíte zadat dvojité lomítko. Například celý název souboru noobs.txt umístěného ve složce hry na disku D: bude muset být zapsán takto:

D:\\hra\\noobs.txt.

Soubor lze otevřít v jednom z následujících režimů:

ios::in - otevřít soubor v režimu čtení dat, tento režim je výchozí režim pro streamy ifstream;

ios::out - otevřít soubor v režimu zápisu dat (v tomto případě jsou zničeny informace o existujícím souboru), tento režim je výchozí režim pro streamy proudu;

ios::app - otevření souboru v režimu zápisu dat na konec souboru;

ios::ate - přesun na konec již otevřeného souboru;

ios::trunc - vymažte soubor, totéž se stane v režimu ios::out;

ios::nocreate - neotevírat soubor, pokud neexistuje;

ios::noreplace - Neotevírejte existující soubor.

Parametr mode může chybět, v takovém případě se soubor otevře ve výchozím režimu pro tento stream.

Po úspěšném otevření souboru (v libovolném režimu) bude proměnná F ukládat true, jinak false. Tím se zkontroluje správnost operace otevření souboru.

Soubor můžete otevřít (vezměme si jako příklad D:\\game\\noobs.txt) v režimu zápisu pomocí jedné z následujících metod:

// První cesta

offstream F;

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

//druhý způsob, režim ios::out je výchozí režim

// Pro tokoutstream

offstream F;

//třetí způsob kombinuje popis proměnné a typ streamu

//a otevřete soubor v jednom příkazu

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

Po otevření souboru v režimu zápisu se vytvoří prázdný soubor, do kterého lze zapisovat informace.

Pokud chcete otevřít existující soubor v režimu předběžného zápisu, použijte jako režim ios::app.

Po otevření souboru v režimu zápisu do něj můžete zapisovat stejným způsobem jako na obrazovce, pouze místo standardního výstupního zařízenícoutmusíte zadat název otevřeného souboru.

Například pro zápis proměnné a do streamu F by výstupní příkaz byl:

Chcete-li sekvenční tisk proměnných b, c, d do proudu G, výstupní příkaz bude:

G<

Stream je uzavřen pomocí operátoru:

PŘÍKLAD:

Vytvořte textový soubor D:\\hra\\noobs.txt a napište do něj n reálných čísel.

#include "stdafx.h"

#zahrnout

#zahrnout

#zahrnout

pomocí jmenného prostoru std;

int main()

setlocale(LC_ALL, "RUS");

int i, n;

dvojité a;

//popisuje proud pro zápis dat do souboru

outstream F;

//otevřít soubor v režimu zápisu,

//režimios:: venve výchozím nastavení nainstalováno

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

//zadejte počet reálných čísel

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

//smyčka pro zadávání reálných čísel

//a zapsat je do souboru

pro (i=0; i

cout<<"a=";

//zadejte číslo

cin >>a;

F<

//uzavření streamu

f.close();

system("pauza");

návrat 0;

_______________________________________________________________

Aby bylo možné číst informace z textového souboru, je nutné deklarovat proměnnou typu ifstream. Poté musíte soubor otevřít pro čtení pomocí operátoru OTEVŘENO. Pokud se proměnná nazývá F, pak první dva příkazy budou následující:

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

Po otevření souboru v režimu čtení z něj můžete číst informace stejným způsobem jako z klávesnice, jen místo tohocinzadejte název proudu, ze kterého se budou data číst.

Chcete-li například číst z proudu F do proměnné a, příkaz input by vypadal takto:

Dvě čísla v textovém editoru jsou považována za oddělená, pokud je mezi nimi alespoň jeden ze znaků: mezera, tabulátor, znak konce řádku. Je dobré, když programátor předem ví, kolik a jaké hodnoty má uložit do textového souboru. Typ hodnot uložených v souboru je však často jednoduše znám a jejich počet se může lišit. Chcete-li tento problém vyřešit, musíte číst hodnoty ze souboru jednu po druhé a před každým čtením zkontrolovat, zda byl dosažen konec souboru. Existuje na to funkce F. eof().

Zde F je název proudu, funkce vrací booleovskou hodnotu: true nebo false, podle toho, zda bylo dosaženo konce souboru. Smyčku pro čtení obsahu celého souboru lze tedy zapsat takto:

//uspořádání pro čtení hodnot ze souboru, spuštění

//cyklus se přeruší, když se dostaneme na konec souboru,

//v tomto případě F.eof() vrátí true

zatímco (!F.eof())

PŘÍKLAD:

Reálná čísla jsou uložena v textovém souboru D:\\hra\\noobs.txt, zobrazte je na obrazovce a vypočítejte jejich počet.

#include "stdafx.h"

#zahrnout

#zahrnout

#zahrnout

#zahrnout

pomocí jmenného prostoru std;

int main()

setlocale(LC_ALL, "RUS");

intn=0;

plovák a;

fstream F;

//otevřít soubor v režimu čtení

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

//pokud byl soubor otevřen správně, pak

//smyčka pro čtení hodnot ze souboru; provádění smyčky bude přerušeno,

//když se dostaneme na konec souboru, v takovém případě F.eof() vrátí true.

zatímco (!F.eof())

//načtení další hodnoty z proudu F do proměnné a

F>>a;

//vypíše hodnotu proměnné a na obrazovku

cout<

//zvýší počet přečtených čísel

//uzavření streamu

f.close();

//zadání počtu přečtených čísel na obrazovce

cout<<"n="<

//pokud byl soubor otevřen nesprávně, pak výstup

//zprávy o absenci takového souboru

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

system("pauza");

návrat 0;

C++. Zpracování binárních souborů

Při zápisu informací do binárního souboru se znaky a čísla zapisují jako sekvence bajtů.

V následujících situacích zapsat data do binárního souboru, potřebujete:

deklarovat proměnnou souboru typu FAIL * pomocí příkazu FILE *název souboru;. Zde název_souboru je název proměnné, kde bude uložen ukazatel na soubor.

zapisovat informace do souboru pomocí funkce fwrite

V následujících situacích myslet si z data z binárního souboru, musíte:

popsat proměnnou typu FILE *

otevřít soubor s funkcí fopen

zavřít soubor funkcí fclose

Základní funkce potřebné pro práci s binárními soubory.

Pro objevy soubor, je určena funkce fopen.

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

Zde název_souboru je řetězec, který ukládá celé jméno otevíraného souboru, mode je řetězec, který definuje režim práce se souborem; jsou možné následující hodnoty:

"rb" - otevření binárního souboru v režimu čtení;

"wb" - vytvoří binární soubor pro zápis; pokud existuje, jeho obsah je vymazán;

"ab" - vytvořit nebo otevřít binární soubor pro připojení na konec souboru;

"rb+" - otevře existující binární soubor v režimu čtení a zápisu;

"wb+" - otevření binárního souboru v režimu čtení-zápis, existující soubor je vymazán;

"ab+" - Binární soubor je otevřen nebo vytvořen pro opravu existujících informací a přidání nových informací na konec souboru.

Funkce vrátí hodnotu NULL v proměnné souboru f, pokud soubor nebyl úspěšně otevřen. Po otevření souboru je k dispozici jeho 0. bajt, ukazatel souboru je 0, jehož hodnota je při čtení nebo zápisu posunuta o přečtený (zapsaný) počet bajtů. Aktuální hodnota ukazatele souboru je číslo bajtu, ze kterého bude probíhat operace čtení nebo zápisu.

Pro zavírání soubor, je určena funkce fclose

int fclose(FILE *název souboru);

Vrátí 0, pokud byl soubor úspěšně uzavřen, jinak NULL.

Funkce odstranění je pro odstranění soubory.

int remove(const char *název souboru);

Tato funkce odstraní soubor s názvem filenema z disku. Soubor, který má být odstraněn, musí být uzavřen. Pokud soubor nelze odstranit, funkce vrátí nenulovou hodnotu.

Pro přejmenování soubory, funkce přejmenování je určena:

int rename(const char *starýsoubor, const char *novýfilename);

První parametr je starý název souboru, druhý je nový. Vrátí 0 po úspěšném dokončení programu.

Čtení z binárního souboru se provádí pomocí funkce fread:

fread(void *ptr, velikost, n, FILE *název souboru);

Funkce fread načte n prvků velikosti size z názvu souboru do pole ptr. Funkce vrací počet přečtených prvků. Po načtení ze souboru se jeho ukazatel posune o n*velikost bytů.

Záznam do binárního souboru se provádí pomocí funkce fwrite:

fwrite(const void *ptr, velikost, n, FILE *název souboru);

Funkce fwrite zapíše n prvků velikosti size do názvu souboru z pole ptr. Funkce vrací počet zapsaných prvků. Po zapsání informace do souboru se ukazatel posune o n*velikost bajtů.

Pro kontrola konce souboru existuje funkce feof:

int feof(FILE *název souboru);

Pokud je dosaženo konce souboru, vrátí nenulovou hodnotu.

PŘÍKLAD:

Vytvořte binární soubor D:\\game\\noobs.dat a napište do něj celé číslo n a n reálných čísel.

#include "stdafx.h"

#zahrnout

pomocí jmenného prostoru std;

int main()

setlocale(LC_ALL, "RUS");

int n, i;

dvojité a;

// vytvoření binárního souboru v režimu zápisu

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

// vstup číslan

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

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

//smyčka pro zadání n reálných čísel

pro (i=0; i

//zadejte další reálné číslo

cout<<"a=";

cin >>a;

//zapíše reálné číslo do binárního souboru

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

// zavřít soubor

fclose(f);

system("pauza");

návrat 0;

PŘÍKLAD:

Zobrazte obsah binárního souboru D:\\game\\noobs.dat vytvořeného v předchozí úloze

#include "stdafx.h"

#zahrnout

pomocí jmenného prostoru std;

int main()

setlocale(LC_ALL, "RUS");

int n, i;

dvojité *a;

SOUBOR *f; //popište proměnnou souboru

//otevření existujícího binárního souboru v režimu čtení

//přečte jedno celé číslo ze souboru do proměnné n

//výstup n na obrazovku

cout<<"n="<

//přidělí paměť pro pole n čísel

a=new double[n];

//načtení n reálných čísel ze souboru do pole a

//vypíše pole na obrazovku

pro (i=0; i

cout<

cout<

// zavřít soubor

fclose(f);

system("pauza");

návrat 0;

Binární- sekvenční datová struktura, po otevření souboru je k dispozici první bajt v něm uložený. Můžete postupně zapisovat nebo číst data ze souboru. Předpokládejme, že potřebujete spočítat patnácté číslo a pak první. Se sériovým přístupem to lze provést následujícím způsobem:

int n, i;

dvojité a;

SOUBOR *f;

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

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

fclose(f);

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

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

fclose(f);

Jak vidíte, čtení čísel ze souboru a následné znovuotevření souboru není nejpohodlnější způsob. Pro přesunutí ukazatele souboru na daný bajt je mnohem pohodlnější použít funkci fseek.

int fseek(FILE *název souboru, dlouhý int offset, int původ);

Funkce nastaví ukazatel na aktuální pozici souboru F v souladu s hodnotou počátku a offsetu. Parametr offset se rovná počtu bajtů, o které bude ukazatel souboru posunut vzhledem k počátku určenému parametrem počátku. Hodnota parametru počátku musí být jedna z následujících hodnot pro offset definovaných v záhlaví stdio.h:

SEEK_SET - od začátku souboru;

SEEK_CUR - z aktuální pozice;

SEEK_END – od konce souboru.

Funkce vrátí nulu, pokud je operace úspěšná, nenulovou, pokud se posun nezdaří.

Funkce fseek ve skutečnosti implementuje přímý přístup k jakékoli hodnotě v souboru. Potřebujete pouze znát umístění (číslo bajtu) hodnoty v souboru. Zvažte použití přímého přístupu v binárních souborech pomocí příkladu řešení následujícího problému.

PŘÍKLAD

V dříve vytvořeném binárním souboru D:\\game\\noobs.dat zaměňte největší a nejmenší z reálných čísel.

Algoritmus pro řešení problému se skládá z následujících kroků:

čtení reálných hodnot ze souboru do pole a.

vyhledejte v poli a maximální (max) a minimální (min) hodnoty a jejich čísla (imax, imin).

posunutí ukazatele souboru na maximální hodnotu a zápis min.

přesunutí ukazatele souboru na minimální hodnotu a zápis max.

Níže je text programu pro řešení problému s komentáři.

#include "stdafx.h"

#zahrnout

pomocí jmenného prostoru std;

int main()

setlocale(LC_ALL, "RUS");

int n, i, imax, imin;

double *a, max, min;

SOUBOR *f;

//otevřít soubor v režimu čtení/zápisu

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

//čtení ze souboru do proměnné n číslo

//skutečná čísla v souboru

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

cout<<"n="<

//přidělení paměti pro ukládání reálných čísel,

//které bude uloženo v poli a

a=new double[n];

//čtení ze souboru do pole a reálných čísel

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

//hledá maximální a minimální prvky

//v poli a a jejich indexy

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

if (a[i]>max)

max=a[i];

pokud (a[i]

min=a[i];

// pohybující se ukazatel Na maximum živel

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

//záznam min místo maximálního prvku souboru

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

// pohybující se ukazatel Na minimální živel

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

//záznam max místo minimálního prvku souboru

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

//uzavření souboru

fclose(f);

// volná paměť

vymazat[ ]A;

system("pauza");