Práce s textovými soubory c. Práce s textovými soubory

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 typ proměnné SOUBOR ( 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é). Provádí se zápis a čtení dat ze souboru následující funkce: 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 popř celé jméno 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 - Vytvořeno nový soubor. Li zadaný soubor existuje, jeho obsah je vymazán a délka souboru je nastavena 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ě. Chyba při otevírání souboru může nastat např metoda Otevřít určeno pro čtení neexistujícího souboru.

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. Ve 32-bit operační systémy obě metody mohou 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 píše do otevřít soubor nSpočítejte bajty z vyrovnávací paměti lpBuf. 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á vám umožní odstranit 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. Vzlétnout nastavit 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.

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.

Poslední aktualizace: 31.10.2015

Třída filestream představuje schopnost číst ze souboru a zapisovat do souboru. Umožňuje pracovat s textovými i binárními soubory.

Zvažte jeho nejdůležitější vlastnosti a metody:

Vlastnost Length: vrací délku proudu v bajtech

Vlastnost Position: vrací aktuální pozici ve streamu

Metoda čtení: Čte data ze souboru do bajtového pole. Vyžaduje tři parametry: int Read(bajtové pole, int offset, int počet) a vrátí počet úspěšně přečtených bajtů. Používají se zde následující parametry:

• pole - pole bajtů, kam budou umístěna data načtená ze souboru

  offset představuje posun v bytech in pole, do kterého budou umístěny čtené bajty

  počet – maximální počet bajtů, které mají být načteny. Pokud je v souboru méně bajtů, přečtou se všechny.

Metoda dlouhé hledání (dlouhý posun, původ SeekOrigin): nastavuje pozici v toku offsetu o počet bajtů zadaný v parametru offset.

Metoda zápisu: Zapíše data z pole bajtů do souboru. Vyžaduje tři parametry: Write (bajtové pole, int offset, int count)

• pole - pole bajtů, odkud budou data zapsána do souboru

  offset - offset v bajtech v poli pole, odkud začít zapisovat bajty do proudu

  počet – maximální počet zapsaných bajtů

FileStream představuje přístup k souborům na úrovni bajtů, takže pokud například potřebujete číst nebo zapisovat jeden nebo více řádků do textového souboru, pak je třeba pole bajtů převést na řetězce pomocí speciálních metod. Pro práci s textovými soubory se proto používají jiné třídy.

Zároveň při práci s různými binárními soubory, které mají určitou strukturu, může být FileStream velmi užitečný pro extrakci určitých informací a jejich zpracování.

Podívejme se na příklad čtení a zápisu do textového souboru:

Console.WriteLine("Zadejte řádek pro zápis do souboru:"); string text = Console.ReadLine(); // zápis do souboru pomocí (FileStream fstream = new FileStream(@"C:\SomeDir\noname\note.txt", FileMode.OpenOrCreate)) ( // převod řetězce na pole bajtů bajtů = System.Text.Encoding.Default. GetBytes(text); // Zápis pole bajtů do souboru fstream.Write(pole, 0, pole.Length); Console.WriteLine("Text je zapsán do souboru"); ) // Čtení ze souboru pomocí (FileStream fstream = Soubor. OpenRead(@"C:\SomeDir\noname\note.txt")) ( // převod řetězce na pole bajtů bajtů = nový bajt; // čtení dat fstream.Read(pole, 0, pole. Length); // dekódování bajtů na řetězec textFromFile = System.Text.Encoding.Default.GetString(pole); Console.WriteLine("Text ze souboru: (0)", textFromFile); ) Console.ReadLine();

Pojďme analyzovat tento příklad. Čtení i zápis používají příkaz using. Nenechte se zmást daný operátor s pomocí direktivy, která obsahuje jmenné prostory na začátku souboru kódu. Příkaz using umožňuje vytvořit objekt v bloku kódu, načež je zavolána metoda Dispose na tomto objektu, a tím je objekt zničen. V tento případ jako takový objekt slouží proměnná fstream.

Objekt fstream je vytvořen dvěma různé způsoby: prostřednictvím konstruktoru a prostřednictvím jedné ze statických metod třídy File.

Zde jsou konstruktoru předány dva parametry: cesta k souboru a výčet FileMode. Tento výčet označuje režim přístupu k souboru a může nabývat následujících hodnot:

Append : Pokud soubor existuje, text se připojí na konec souboru. Pokud soubor neexistuje, je vytvořen. Soubor je otevřen pouze pro zápis.

Vytvořit: Vytvoří se nový soubor. Pokud takový soubor již existuje, je přepsán

CreateNew : Vytvoří se nový soubor. Pokud takový soubor již existuje, pak aplikace vyvolá chybu

Otevřít: Otevře soubor. Pokud soubor neexistuje, je vyvolána výjimka.

OpenOrCreate : pokud soubor existuje, je otevřen, pokud ne, je vytvořen nový

Zkrátit: Pokud soubor existuje, bude přepsán. Soubor je otevřen pouze pro zápis.

Statická metoda OpenRead třídy File otevře soubor pro čtení a vrátí objekt FileStream.

Konstruktér třídy FileStream má také řadu přetížených verzí, které umožňují doladit vytvořený objekt. Všechny tyto verze lze zobrazit na msdn.

Zápis i čtení používají objekt kódování Encoding.Default ze jmenného prostoru System.Text. V tomto případě používáme dvě jeho metody: GetBytes k získání bajtového pole z řetězce a GetString k získání řetězce z bajtového pole.

Výsledkem je, že řetězec, který jsme zadali, se zapíše do souboru note.txt. Ve skutečnosti se jedná o binární soubor (nikoli textový), i když pokud do něj napíšeme pouze řádek, můžeme tento soubor vidět v lidsky čitelné podobě, když jej otevřeme v textový editor. Pokud do něj ale zapíšeme náhodné bajty, například:

Fstream.WriteByte(13); fstream.WriteByte(103);

Pak můžeme mít problém to pochopit. Proto jsou samostatné třídy navrženy pro přímou práci s textovými soubory – StreamReader a StreamWriter.

Náhodný přístup k souboru

Často binární soubory představují specifickou strukturu. A při znalosti této struktury můžeme vzít potřebnou část informací ze souboru nebo naopak zapsat určitou sadu bajtů na určité místo v souboru. Například v souborech wav začínají samotná zvuková data na 44 bajtech a až 44 bajtů jsou různá metadata - počet zvukových kanálů, vzorkovací frekvence atd.

Pomocí metody Seek() můžeme ovládat pozici kurzoru proudu, ze kterého se soubor čte nebo do kterého se zapisuje. Tato metoda má dva parametry: offset (offset) a pozici v souboru. Pozice v souboru je popsána třemi hodnotami:

SeekOrigin.Begin : začátek souboru

SeekOrigin.End : konec souboru

SeekOrigin.Current : aktuální pozice v souboru

Kurzor proudu, ze kterého začíná čtení nebo zápis, se posune dopředu o hodnotu offsetu vzhledem k pozici zadané jako druhý parametr. Posun může být záporný, pak se kurzor přesune zpět, pokud je kladný, pak dopředu.

Podívejme se na příklad:

Pomocí System.IO; pomocí System.Text; class Program ( static void Main(string args) ( string text = "hello world"; // zápis do souboru pomocí (FileStream fstream = new FileStream(@"D:\note.dat", FileMode.OpenOrCreate)) ( // převést řetězec na bajty byte input = Encoding.Default.GetBytes(text); // zapsat pole bajtů do souboru fstream.Write(input, 0, input.Length); Console.WriteLine("Text zapsaný do souboru"); / / přesunout ukazatel na konec souboru, na konec souboru - pět bajtů fstream.Seek(-5, SeekOrigin.End); // mínus 5 znaků od konce streamu // čtení čtyř znaků z aktuální pozice byte output = nový byte; fstream.Read( output, 0, output.Length); // dekódování bajtů do řetězce textFromFile = Encoding.Default.GetString(output); Console.WriteLine("Text ze souboru: (0)", textFromFile); // worl // nahrazení v souboru word world na word house řetězec nahraditText = "house"; fstream.Seek(-5, SeekOrigin.End); // minus 5 znaků od konce vstup proudu = Encoding.Default.GetBytes(replaceText);fstream.Write(input , 0, input.Length); // přečte celý soubor // vrátí ukazatel na začátek souboru fstream.Seek(0, SeekOrigin.Begin); výstup = nový bajt; fstream.Read(výstup, 0, výstup.Délka); // dekódování bajtů na řetězec textFromFile = Encoding.Default.GetString(output); Console.WriteLine("Text ze souboru: (0)", textFromFile); // ahoj dome ) Console.Read(); ))

Výstup konzole:

Text zapsaný do souboru Text ze souboru: worl Text ze souboru: hello house

Volání fstream.Seek(-5, SeekOrigin.End) přesune kurzor streamu na konec souborů o pět znaků zpět:

To znamená, že po zapsání řetězce "hello world" do nového souboru bude kurzor na pozici znaku "w".

Poté přečteme čtyři bajty začínající znakem "w". V tomto kódování bude 1 znak představovat 1 bajt. Proto čtení 4 bajtů bude ekvivalentní čtení čtyř znaků: "svět".

Poté se opět přesuneme na konec souboru, nedosáhneme konce pěti znaků (tedy opět z pozice znaku "w") a napíšeme řádek "dům". Řetězec "dům" tedy nahrazuje řetězec "svět".

Uzavření streamu

Výše uvedené příklady používají konstrukci using k uzavření proudu. Po dokončení všech příkazů a výrazů v bloku using je objekt FileStream zničen. Můžeme však zvolit jiný způsob:

FileStream fstream = null; zkuste ( fstream = new FileStream(@"D:\note3.dat", FileMode.OpenOrCreate); // operace streamování ) catch(Exception ex) ( ) nakonec ( if (fstream != null) fstream.Close(); )

Pokud nepoužijeme konstrukci using, pak musíme explicitně zavolat metodu Close(): fstream.Close()

Již jsme se naučili zapisovat informace do textového souboru. – Pokud jste se to nenaučili, podívejte se na předchozí článek. Je to popsané a podrobné

Co když ale soubor již existuje a potřebujeme z něj načíst informace pro zpracování? Naštěstí je to také docela jednoduché. Připomínám, že existuje několik možností pro realizaci tohoto úkolu, popsal jsem pouze jednu z nich. Je popsán ten, který se mi z nějakého důvodu zdá pro vnímání nejjednodušší.

#zahrnout

int main()
{
char s1 //Proměnná přečte řetězec
ifstream in("C:\\\FromC\\myfile.txt" ); //Otevření souboru pro čtení informací
v >>s1 ; //číst řádek
in.close() // Zavírání souboru

cout<Výstupní hodnota s1 na obrazovce
návrat 0;
}

Zde je nejjednodušší program pro čtení prvního řádku z textového souboru umístěného podél cesty
C:\\\FromC\\myfile.txt -
Jelikož se jedná o pokračování minulého článku, rozhodl jsem se použít soubor, který jsme tam vytvořili. Potíže s tím by pravděpodobně neměly nastat.
Ale zpět ke kódu. Nejprve otevřeme soubor, abychom z něj přečetli informace, k tomu použijeme příkaz pokud stream, v závorkách uvádíme buď název souboru, nebo cestu k souboru, jako jsem to udělal já. („C:\\\FromC\\myfile.txt“ );
Když jsme soubor otevřeli, abychom si z něj něco přečetli, deklarovali jsme jednu proměnnou typu char-
char s1
Nyní nám zbývá pouze přiřadit do proměnné hodnotu řádku ze souboru. To je to, co děláme jako tým. v
Dávejte pozor na úhlové držáky v >>
Ve skutečnosti, jak by mělo být patrné z komentářů k programovému kódu, aby proměnná přiřadila čitelnou hodnotu, musíme ji napsat za v >>
v >>s1 ;

Zdá se, že to není nijak zvlášť obtížný úkol, zvláště pokud jste již dokonale zvládli a naučili se používat materiál z minulého článku - vše je naprosto stejné, pouze 2 týmy se liší

Vytvoření souboru a zápis informací do něj C++

outstream ven ( Název souboru );
ven<< (Napsaný řetězec);
ven.zavřít();
=============================

Čtení textu ze souboru a zobrazování textu na obrazovce v C++

ifstream v (Název souboru );
v>> (Čtení řádku);
v.zavřít();(Zavřete soubor)
============================
Pojďme psát jednoduchý program, který přečte textový vstup z klávesnice a zapíše jej do souboru:

#zahrnout
#zahrnout

int main()
{
\\ 3 budoucí řádky
clrscsr(); // Vymazání obrazovky

cout<<“Wwedi pervuu stroku” ; cin >>a ; endl;
cout<<“Wwedi wtoruu stroku” ; cin >>b ; endl;
cout<<“Wwedi tretuu stroku” ; cin >>c ; endl;
clrscr(); //

/*Začněte pracovat se souborem*/
ofstream out("C:\\\FromC\\myfile.txt" ); //Otevření souboru pro zápis
ven<Napište první řádek
ven<Napište druhý řádek
ven<Napište třetí řádek
out.close(); // Zavírání souboru

//Resetování proměnných

pro (int i = 0 ;i<=255 ;i ++)
(a =*““; b =*““; c =*““ ;)

ifstream in(„C:\\\FromC\\myfile.txt“ );
v >>a >>b >>c ; //Každý nový řádek načteme do nové proměnné
přiložit(); // Zavírání souboru

/* */

pro (i =0 ;a !=*"" ;i ++)
{
if (i >velikost(a)) přestávka ;
cout<
}
cout<<“\n” ; \\

/* */

{
if (i >velikost(b)) přestávka ;
cout<
}
cout<<“\n” ; \\ Přesuňte kurzor na nový řádek

/* */

pro (i =0 ;c !=*““ ;i ++)
{
if (i >velikost(c)) přestávka ;
cout<<с ;
}

návrat 0;
}
===================

Ve výše uvedených příkladech je jeden takový OBROVSKÝ vada. Pokud se pokusíme zadat řádek obsahující mezery, pak program nebude fungovat tak, jak potřebujeme. Pravděpodobně nejen já, ale i mnoho dalších lidí narazilo na tuto chybu. Chybně zadaný kód proto nechávám, abyste viděli, s čím se můžete setkat.

Vzhledem k tomu, že doma žádné knihy nejsou, začal jsem opět brouzdat po internetu a našel spoustu nejrůznějších záludných nesmyslů. Nějak jsem však našel řešení mého problému.
Pomohlo mi, že jsem si přečetl o čem cout podporuje jeho metody. A na internetu všechny rady směřují k používání funkce getline Ke svému štěstí jsem velmi rychle našel, jak tuto funkci použít a následně ji použil v kódu.
Obecně stojí za to zmínit a popsat tuto funkci, ale zatím jí opravdu nerozumím, jen chápu, že je třeba ji používat a rozumím tomu, takže uvádím správnější příklad našeho vyvíjeného programu:

#zahrnout
#zahrnout

int main()
{
char a ,b ,c ; \\ 3 budoucí řádky
clrscsr(); // Vymazání obrazovky

/* Zadejte hodnoty pro proměnné */

cout<<“Wwedi pervuu stroku” ; cin.getline(a,velikost(a)); endl;
cout<<“Wwedi wtoruu stroku” ; cin.getline(a,velikost(b)); endl;
cout<<“Wwedi tretuu stroku” ; cin.getline(a,sizeof(c)); endl;
clrscr(); //Po zadání hodnot se obrazovka vymaže

/*Začněte pracovat se souborem*/
ofstream out("C:\\\FromC\\myfile.txt"); // Otevření souboru pro zápis
ven<Napište první řádek
ven<Napište druhý řádek
ven<Napište třetí řádek
out.close(); // Zavírání souboru

//Resetování proměnných

pro (int i = 0 ;i<=255 ;i ++)
(a =*““; b =*““; c=*““ ;)

/*Pokračovat v práci se souborem*/

pokud stream v („C:\\\FromC\\myfile.txt“ );
in.getline(a,velikost(a));// A
in.getline(b,velikost(b));// Čtení řetězce do proměnné b
in.getline(c,sizeof(c)); // Čtení řetězce do proměnné C
přiložit(); // Zavírání souboru

/* Přečteme první řádek znak po znaku a zobrazíme jej na obrazovce */

pro (i =0 ;a !=*"" ;i++)
{
if (i >velikost(a)) přestávka ;
cout<
}
cout<<“\n” ; \\ Přesuňte kurzor na nový řádek

/* Druhý řádek čteme znak po znaku a zobrazujeme jej na obrazovce */

pro (i =0 ;b !=*““ ;i ++)
{
if (i >velikost(b)) přestávka ;
cout<
}
cout<<“\n” ; \\ Přesuňte kurzor na nový řádek

/* Třetí řádek čteme znak po znaku a zobrazujeme jej na obrazovce */

pro (i =0 ;c !=*““ ;i++)
{
if (i>sizeof(c)) přestávka ;
cout<<с[i];
}

getch(); \\Čekání na stisknutí klávesy Enter
návrat 0;
}
===================

V tomto materiálu je analyzován příklad čtení informací znak po znaku. Jelikož jsem nepopisoval práci s proměnnými typu char, pak mohou začátečníci zaznamenat určité potíže s porozuměním kódu. Jen jsem nevěděl jaký typ char má některé funkce a myslel si, že je vše jednodušší. Některé nepochopitelné momenty výše uvedeného programu si proto můžete přečíst v následujícím článku. práce s char PROTI C++ pro začátečníky

Jinak by uvedený příklad, jak číst řádky z textového souboru v C++, měl být přístupný a vcelku srozumitelný. Toto není nejlepší možnost implementace právě teď a vynechal jsem některé důležité body, ale protože se začínáme učit jazyk C ++, je to prozatím docela dost. Později asi přijdu ke ztraceným, ale teď je potřeba vnímat jen to nejnutnější.

Pokud tomuto materiálu společně s Vámi rozumíme, posunuli jsme se o malý krůček k naší profesionalitě.

Poznámka:
přestávka ;– Toto je příkaz, který opustí smyčku. Máme počítadlo cyklů pro bude větší než deklarovaná velikost proměnné char, pak smyčku násilně opustíme
!= – toto je naše podmínka. Označuje takovou stavovou nerovnost
jestliže(a !=b)- číst jakoby A ne rovné b

endl; - Toto je překlad kurzoru na nový řádek uvnitř konzoly (pokud tomu rozumím)
Tento příkaz je podobný jako „\n“

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, je vrácena hodnota 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);