Rozdział 9. Odczytywanie i zapisywanie plików

> Dodaj do ulubionych

Wszystkie przedstawione do tej pory programy s─ů wzgl─Ödnie proste, czyli w sam raz dla kogo┼Ť, kto dopiero uczy si─Ö programowa─ç. Dzi─Öki zdobytym podstawom j─Özyka C++ przy odrobinie praktyki b─Ödziesz w stanie pisa─ç tak┼╝e bardziej zaawansowane programy. Brakuje Ci jednak jeszcze wiedzy na jeden wa┼╝ny temat: pracy z plikami.

Umiesz ju┼╝ wy┼Ťwietla─ç dane na ekranie i pobiera─ç informacje od u┼╝ytkownika z konsoli. Na pewno si─Ö zgodzisz, ┼╝e interakcja z sam─ů konsol─ů to troch─Ö za ma┼éo. Pomy┼Ťl o takich programach, jak Notatnik czy ┼Ťrodowisko programistyczne, kt├│rego u┼╝ywasz albo arkusz kalkulacyjny. Wszystkie one potrafi─ů zapisywa─ç i odczytywa─ç pliki. Tak┼╝e w programowaniu gier jest to bardzo potrzebne. Opr├│cz plik├│w do zapisywania aktualnego stanu gry w grach wykorzystywane s─ů te┼╝ pliki graficzne, wideo, muzyczne i inne. M├│wi─ůc kr├│tko, program kt├│ry nie wsp├│┼épracuje z plikami ma powa┼╝nie ograniczon─ů funkcjonalno┼Ť─ç.

Zatem bierzemy si─Ö do pracy. Je┼Ťli wiesz jak pos┼éugiwa─ç si─Ö instrukcjami cin i cout, to bez trudu nauczysz si─Ö te┼╝ dzia┼éa─ç na plikach.

9.1. Zapisywanie danych w pliku

Prac─Ö z plikiem rozpoczyna si─Ö od jego otwarcia. Gdy plik jest otwarty, dalsze czynno┼Ťci wykonuje si─Ö tak samo, jak przy u┼╝yciu instrukcji cin i cout, tzn. za pomoc─ů operator├│w << i >>. Uwierz mi, nauczysz si─Ö tego w mig.

Kiedy jest mowa o komunikacji programu z obiektami zewn─Ötrznymi, u┼╝ywa si─Ö poj─Öcia strumienia. W tym rozdziale interesowa─ç nas b─Öd─ů strumienie plikowe, czyli strumienie umo┼╝liwiaj─ůce zapis i odczyt plik├│w.

9.1.1. Nagłówek fstream

Jak to zwykle bywa w j─Özyku C++, gdy potrzebujemy jakiej┼Ť funkcjonalno┼Ťci, musimy do┼é─ůczy─ç do programu specjalny plik nag┼é├│wkowy. Narz─Ödzia do pracy z plikami znajduj─ů si─Ö w nag┼é├│wku fstream, kt├│ry do┼é─ůczamy na pocz─ůtku programu za pomoc─ů dyrektywy #include <fstream>.

Najwa┼╝niejsza r├│┼╝nica mi─Ödzy strumieniem wej┼Ťcia i wyj┼Ťcia a strumieniem plikowym polega na tym, ┼╝e w tym drugim przypadku ka┼╝dy plik musi mie─ç utworzony osobny strumie┼ä. Najpierw nauczymy si─Ö tworzy─ç strumienie wyj┼Ťciowe, czyli umo┼╝liwiaj─ůce odczyt danych z plik├│w.

9.1.2. Otwieranie pliku do zapisu

Faktycznie strumienie s─ů obiektami. Przypomn─Ö, ┼╝e j─Özyk C++ jest j─Özykiem obiektowym i strumienie s─ů po prosty jednymi z jego wielu obiekt├│w.

Nie martw si─Ö, je┼Ťli nie wiesz co to jest obiekt. Wszystkiego dowiesz si─Ö p├│┼║niej, a na razie obiekty wyobra┼╝aj sobie jako du┼╝e zmienne. Zawieraj─ů one wiele informacji o otwartych plikach i udost─Öpniaj─ů r├│┼╝ne funkcje, takie jak np. do zamykania plik├│w, przechodzenia na ich pocz─ůtek itp.

Co ciekawe, strumienie plikowe definiuje si─Ö dok┼éadnie tak samo, jak zwyk┼ée zmienne. Po prostu definiujemy zmienn─ů typu ofstream o warto┼Ťci b─Öd─ůcej ┼Ťcie┼╝k─ů do pliku, kt├│ry chcemy otworzy─ç:

#include <iostream>
#include <fstream>
using namespace std;

int main()
{
    ofstream mojStrumien("C:/Nanoc/scores.txt");    // Deklaracja strumienia do zapisu w pliku
                                                // C:/Nanoc/scores.txt
    return 0;
}

┼Ücie┼╝k─Ö do pliku nale┼╝y poda─ç w cudzys┼éowie. Mo┼╝na stosowa─ç dwa rodzaje ┼Ťcie┼╝ek:

  • ┼Ücie┼╝ka bezwzgl─Ödna: jest to ┼Ťcie┼╝ka odnosz─ůca si─Ö do katalogu g┼é├│wnego na dysku, np. C:/Nano/C++/Pliki/scores.txt
  • ┼Ücie┼╝ka wzgl─Ödna: jest to ┼Ťcie┼╝ka okre┼Ťlaj─ůca po┼éo┼╝enie pliku wzgl─Ödem miejsca, w kt├│rym znajduje si─Ö program, np. Pliki/scores.txt, je┼Ťli program znajduje si─Ö w folderze C:/Nanoc/C++.

Teraz mo┼╝na u┼╝y─ç utworzonego strumienia do zapisania danych w pliku.

Najcz─Ö┼Ťciej nazwa pliku jest okre┼Ťlona jako ┼éa┼äcuch znak├│w. W├│wczas do jego otwarcia nale┼╝y u┼╝y─ç funkcji c_str():

string const nazwaPliku("C:/Nanoc/scores.txt");

ofstream mojStrumien(nazwaPliku.c_str());    // Definicja strumienia do zapisu danych w pliku.

Podczas otwierania pliku mog─ů mie─ç miejsce niespodziewane zdarzenia, np. plik nie zostanie odnaleziony albo dysk twardy b─Ödzie zape┼éniony. Dlatego te┼╝ zawsze przy otwieraniu pliku nale┼╝y sprawdzi─ç, czy operacja si─Ö powiod┼éa. Do tego celu mo┼╝na u┼╝y─ç konstrukcji if(mojStrumien). Je┼Ťli wynik tego testu jest negatywny, wiadomo, ┼╝e wyst─ůpi┼é jaki┼Ť problem i nie mo┼╝na u┼╝y─ç ┼╝─ůdanego pliku.

ofstream mojStrumien("C:/Nanoc/scores.txt"); // Pr├│bujemy otworzy─ç plik

if(mojStrumien)    // Sprawdzamy czy plik został otwarty.
{
    // Wszystko jest w porz─ůdku, mo┼╝na pracowa─ç na pliku
}
else
{
    cout << "BŁĄD: nie można otworzyć pliku." << endl;
}

Mo┼╝emy w ko┼äcu zapisa─ç jakie┼Ť dane w pliku. Jak si─Ö przekonasz, nie jest to wcale trudne.

9.1.3. Zapisywanie danych w pliku

Napisa┼éem, ┼╝e z plikami pracuje si─Ö podobnie, jak ze strumieniami cout i cin. Tak jest rzeczywi┼Ťcie, poniewa┼╝ w przypadku zapisu do pliku u┼╝ywa si─Ö operatora <<:

#include <iostream>
#include <fstream>
#include <string>
using namespace std;

int main()
{
    string const nazwaPliku("E:/scores.txt");
    ofstream mojStrumien(nazwaPliku.c_str());

    if(mojStrumien)    
    {
        mojStrumien << "Witaj, jestem zdaniem zapisanym w pliku." << endl;
        mojStrumien << 42.1337 << endl;
        int age(23);
        mojStrumien << "Mam " << age << " lata." << endl;
    }
    else
    {
        cout << "BŁĄD: nie można otworzyć pliku." << endl;
    }
    return 0;
}

Po uruchomieniu tego programu na moim dysku znalaz┼é si─Ö plik o nazwie scores.txt o nast─Öpuj─ůcej zawarto┼Ťci:

Zawarto┼Ť─ç pliku zapisana przez program
Zawarto┼Ť─ç pliku zapisana przez program

Wypr├│buj go sam! Mo┼╝esz na przyk┼éad napisa─ç program pobieraj─ůcy od u┼╝ytkownika imi─Ö i wiek i zapisuj─ůcy te informacje w pliku tekstowym.

9.1.4. Tryby otwarcia pliku

Pozosta┼éa nam jeszcze jedna kwestia do wyja┼Ťnienia. Co si─Ö dzieje, gdy plik o podanej nazwie ju┼╝ istnieje? Zostanie on wyczyszczony i zapisany od nowa, co nie zawsze jest tym, czego by┼Ťmy chcieli. Wyobra┼║ sobie na przyk┼éad plik do przechowywania listy czynno┼Ťci wykonanych przez u┼╝ytkownika. Nie chcemy za ka┼╝dym razem kasowa─ç jego zawarto┼Ťci, tylko dodawa─ç na jego ko┼äcu coraz to nowe wiersze danych.

Aby zapisa─ç informacje na ko┼äcu pliku, nale┼╝y wyrazi─ç ten zamiar podczas jego otwierania. W tym celu dodaje si─Ö specjalny parametr do instrukcji tworz─ůcej strumie┼ä:

ofstream mojStrumien("C:/Nanoc/scores.txt", ios::app);

Teraz nowe dane nie b─Öd─ů powodowa┼éy skasowania starych, tylko b─Öd─ů dodawane na ko┼äcu pliku.

9.2. Odczytywanie pliku

Wiesz ju┼╝ jak zapisa─ç dane w pliku, a wi─Öc czas nauczy─ç si─Ö tak┼╝e je odczytywa─ç. Czynno┼Ť─ç t─Ö wykonuje si─Ö bardzo podobnie do poprzedniej.

9.2.1. Otwieranie pliku do odczytu

Zasada dzia┼éania jest dok┼éadnie taka sama, jak przy zapisywaniu plik├│w, tylko zamiast strumienia ofstream b─Ödziemy u┼╝ywa─ç strumienia ifstream. Oto og├│lna struktura kodu do odczytywania zawarto┼Ťci pliku:

ifstream mojStrumien("C:/Nanoc/C++/data.txt");  // Otwarcie pliku do odczytu

if(mojStrumien)
{
    // Wszystko gotowe do odczytu.
}
else
{
    cout << "BŁĄD: nie można otworzyć pliku do odczytu." << endl;
}

Jak wida─ç, nic nowego tu nie ma. Plik mo┼╝na odczyta─ç na trzy sposoby:

  1. Linijka po linijce przy u┼╝yciu funkcji getLine().
  2. Słowo po słowie przy użyciu operatora >>.
  3. Znak po znaku przy u┼╝yciu funkcji get().

Poniżej znajduje się szczegółowy opis każdej z tych metod.

Odczytywanie pliku linijka po linijce

Ta metoda polega na odczytaniu jednej linijki tekstu i zapisaniu jej jako łańcucha znaków.

string linia;
getline(mojStrumien, linia); // Odczytanie jednej linii tekstu

Efekt zastosowania tej techniki jest identyczny, jak u┼╝ycia instrukcji cin.

Odczytywanie pliku słowo po słowie

Ta metoda również jest łatwa do opanowania. Spójrz na poniższy przykład:

double liczba;
mojStrumien >> liczba; // Odczytanie liczby zmiennoprzecinkowej
string slowo;
mojStrumien >> slowo; // Odczytanie słowa z pliku

W tym przypadku odczytywane jest wszystko, co znajduje si─Ö mi─Ödzy miejscem w pliku, w kt├│rym aktualnie si─Ö znajdujemy a najbli┼╝sz─ů spacj─ů. Odczytany tekst jest traktowany jako typ double, int lub string w zale┼╝no┼Ťci od typu u┼╝ytej zmiennej.

Odczytywanie pliku znak po znaku

Ta metoda polega na odczytywaniu z pliku po jednym znaku i jako jedyna z wszystkich opisanych jest dla nas ca┼ékiem nowa. Ale oczywi┼Ťcie tak jak poprzednie, r├│wnie┼╝ ┼éatwo j─ů opanowa─ç.

char a;
mojStrumien.get(a);

Powy┼╝szy kod odczyta jeden znak i zapisze go w zmiennej a.

9.2.2. Odczytywanie całego pliku

Cz─Östo trzeba odczyta─ç ca┼é─ů zawarto┼Ť─ç pliku. Na razie pokaza┼éem Ci jak odczytywa─ç dane z plik├│w, ale jeszcze nie wyja┼Ťni┼éem, jak zako┼äczy─ç wczytywanie, gdy dojdzie si─Ö do ko┼äca pliku.

Aby dowiedzie─ç si─Ö czy mo┼╝na kontynuowa─ç odczytywanie danych, nale┼╝y u┼╝y─ç warto┼Ťci zwrotnej funkcji getline(). Funkcja ta nie tylko wczytuje linie zawarto┼Ťci plik├│w, ale dodatkowo zwraca warto┼Ť─ç logiczn─ů informuj─ůc─ů, czy mo┼╝na kontynuowa─ç odczyt. Zatem je┼Ťli funkcja ta zwr├│ci warto┼Ť─ç true, to wiadomo, ┼╝e mo┼╝na kontynuowa─ç odczytywanie. Je┼Ťli natomiast zwr├│ci false, jest to znak, ┼╝e zosta┼é osi─ůgni─Öty koniec pliku albo wyst─ůpi┼é b┼é─ůd. W obu tych przypadkach nale┼╝y zako┼äczy─ç operacj─Ö odczytu.

Pami─Ötasz jeszcze p─Ötle? U┼╝yjemy jednej z nich, aby odczyta─ç zawarto┼Ť─ç pliku do samego ko┼äca. Najlepiej nadaje si─Ö do tego p─Ötla while:

#include <iostream>
#include <fstream>
#include <string>
using namespace std; 

int main()
{
    ifstream plik("C:/Nanoc/plik.txt");

    if(plik)
    {
         // Uda┼éo si─Ö otworzy─ç plik, a wi─Öc mo┼╝na rozpocz─ů─ç odczytywanie

        string linia;     // Zmienna do przechowywania odczytanych wierszy tekstu

        while(getline(plik, linia))    // Je┼Ťli jeszcze nie nast─ůpi┼é koniec pliku, czytamy dalej
        {

            cout << linia << endl; // Wy┼Ťwietlamy odczytany tekst w konsoli
                                   // Mo┼╝na te┼╝ zrobi─ç z nim co┼Ť innego
        }
    }
    else
    {
        cout << "BŁĄD: nie można otworzyć pliku do odczytu." << endl;
    }

    return 0;
}

Gdy wczytamy lini─Ö tekstu, mo┼╝emy z ni─ů zrobi─ç, co tylko nam si─Ö podoba. Ten program tylko wy┼Ťwietla po kolei ka┼╝dy wiersz tre┼Ťci, ale w prawdziwym programie by┼éyby one u┼╝ywane w inny spos├│b. Jedynym ograniczeniem jest Twoja wyobra┼║nia.

Powy┼╝sza metoda odczytywania zawarto┼Ťci plik├│w jest stosowana najcz─Ö┼Ťciej ze wszystkich. Po wczytaniu linii tekstu do ┼éa┼äcucha znak├│w mo┼╝na na niej pracowa─ç przy u┼╝yciu funkcji operuj─ůcych na ┼éa┼äcuchach.

9.3. Kilka sztuczek

Musisz poznać jeszcze tylko kilka sztuczek i będziesz wiedział już wszystko, co trzeba wiedzieć o technikach pracy z plikami.

9.3.1. Wczesne zamykanie pliku

Na pocz─ůtku tego rozdzia┼éu napisa┼éem, jak otworzy─ç plik, ale jeszcze do tej pory nie wyja┼Ťni┼éem, jak go potem zamkn─ů─ç. Nie zapomnia┼éem o tym, po prostu robienie tego nie jest konieczne. Otwarte pliki s─ů automatycznie zamykane, gdy program ko┼äczy wykonywanie bloku, w kt├│rym zosta┼éy utworzone ich strumienie.

void f()
{
    ofstream strumien("C:/Nanoc/data.txt");   // Plik jest otwarty

    // Operacje na pliku

}   // Koniec bloku, a wi─Öc w tym miejscu plik zostanie automatycznie zamkni─Öty

Nie trzeba nic robi─ç, aby zamkn─ů─ç plik. I ca┼ée szcz─Ö┼Ťcie, bo dzi─Öki temu nigdy o tym nie zapomnimy.

Czasami jednak trzeba zamkn─ů─ç plik wcze┼Ťniej, ni┼╝ powinno to nast─ůpi─ç automatycznie. W takim przypadku nale┼╝y u┼╝y─ç funkcji close().

void f()
{
    ofstream strumien("C:/Nanoc/data.txt");   // Plik jest otwarty

    // Operacje na pliku

    strumien.close(); // Zamkni─Öcie pliku
                  // Od tego miejsca nie mo┼╝na dokonywa─ç zapisu w pliku
}

Można też zadeklarować strumień, ale otwarcie pliku odłożyć na później. Służy do tego funkcja open().

void f()
{
    ofstream strumien;   // Strumień bez przypisanego pliku

    strumien.open("C:/Nanoc/data.txt");  // Otwarcie pliku C:/Nanoc/data.txt

    // Operacje na pliku

    flux.close(); // Zamkni─Öcie pliku
                  // Od tego miejsca nie mo┼╝na dokonywa─ç zapisu w pliku
}

Pragn─Ö podkre┼Ťli─ç, ┼╝e wykonywanie powy┼╝szych czynno┼Ťci jest rzadko konieczne. Zazwyczaj wystarczy bezpo┼Ťrednie otwarcie pliku i pozostawienie go do automatycznego zamkni─Öcia.

9.3.2. Kursor w pliku

Na chwil─Ö zag┼é─Öbimy si─Ö troch─Ö bardziej w szczeg├│┼éy techniczne, aby dok┼éadnie pozna─ç mechanizm odczytywania zawarto┼Ťci plik├│w. Gdy otworzymy plik w edytorze tekstu, np. Notatniku, znajdziemy w nim kursor wskazuj─ůcy miejsce, w kt├│rym aktualnie si─Ö znajdujemy. Na poni┼╝szym rysunku kursor znajduje si─Ö za drugim „s” w s┼éowie „Issac” w czwartym wierszu.

Kursor w Notatniku
Kursor w Notatniku

Gdy naci┼Ťniesz jaki┼Ť klawisz na klawiaturze, w miejscu, w kt├│rym znajduje si─Ö teraz kursor pojawi si─Ö nowa litera. Analogicznie w j─Özyku C++ istnieje odpowiednik kursora, za pomoc─ů kt├│rego mo┼╝na wybra─ç miejsce do wpisywania danych. Sp├│jrz na poni┼╝szy kod:

ifstream plik("C:/Nanoc/scores.txt")

Instrukcja ta spowoduje otwarcie pliku C:/Nanoc/scores.txt i umieszczenie kursora na samym jego pocz─ůtku. Gdy wczytamy pierwsze s┼éowo z tego pliku, otrzymamy ┼éa┼äcuch znak├│w Nanoc:. Po tej operacji „kursor C++” przesunie si─Ö na pocz─ůtek nast─Öpnego s┼éowa, w miejsce pokazane na poni┼╝szym rysunku:

Przesuni─Öcie kursora w Notatniku
Przesuni─Öcie kursora w Notatniku

Nast─Öpnym wczytanym s┼éowem b─Ödzie 118218 itd. Oznacza to, ┼╝e w ten spos├│b zawarto┼Ť─ç pliku mo┼╝na przegl─ůda─ç tylko sekwencyjnie. To nie jest zbyt praktyczne.

Na szcz─Ö┼Ťcie istniej─ů sposoby na zmienianie pozycji kursora w pliku. Mo┼╝na na przyk┼éad przesun─ů─ç go do 20 miejsca od pocz─ůtku pliku albo o 32 znaki do przodu wzgl─Ödem bie┼╝─ůcego po┼éo┼╝enia. Dzi─Öki temu mo┼╝na odczyta─ç dok┼éadnie te fragmenty pliku, kt├│re nas interesuj─ů.

Aby to jednak zrobi─ç, najpierw trzeba dowiedzie─ç si─Ö, w kt├│rym miejscu pliku aktualnie si─Ö znajdujemy. Dopiero potem mo┼╝emy przesun─ů─ç kursor. Poni┼╝ej dowiesz si─Ö, jak to zrobi─ç.

9.3.3. Sprawdzanie pozycji kursora w pliku

Istniej─ů specjalne funkcje do sprawdzania, kt├│ry bajt w pliku wskazuje aktualnie kursor. Inaczej m├│wi─ůc funkcje te pozwalaj─ů sprawdzi─ç, na kt├│rym znaku w danej chwili jest kursor. Pisz─Ö funkcje, nie funkcja, poniewa┼╝ s─ů ich dwie: po jednej dla strumienia wej┼Ťciowego i wyj┼Ťciowego. Niestety ich nazwy brzmi─ů do┼Ť─ç dziwnie: tellg() (dla strumienia ifstream) i tellp() (dla strumienia ofstream). Na szcz─Ö┼Ťcie u┼╝ywa si─Ö ich tak samo.

ofstream plik("C:/Nanoc/data.txt");

int pozycja = plik.tellp(); // Sprawdzamy pozycj─Ö

cout << "Jeste┼Ťmy na znaku nr " << pozycja << " w pliku." << endl;

9.3.4. Przesuwanie kursora

Do przesuwania kursora r├│wnie┼╝ s┼éu┼╝─ů dwie funkcje: seekg() (dla strumienia ifstream) i seekp() (dla strumienia ofstream).

Tych funkcji również używa się tak samo, a więc poniżej przedstawiam przykład użycia tylko jednej z nich:

strumien.seekp(liczbaZnakow, pozycja);

Parametr pozycja mo┼╝e przyjmowa─ç jedn─ů z trzech warto┼Ťci:

  • ios::beg — pocz─ůtek pliku
  • ios::end — koniec pliku
  • ios::cur — bie┼╝─ůca pozycja

Aby na przyk┼éad ustawi─ç si─Ö dziesi─Ö─ç znak├│w za pocz─ůtkiem pliku, nale┼╝y napisa─ç instrukcj─Ö strumien.seekp(10, ios::beg);. A ┼╝eby przesun─ů─ç kursor o 20 znak├│w dalej od miejsca, w kt├│rym si─Ö on aktualnie znajduje, nale┼╝y napisa─ç strumien.seekp(20, ios::cur);. Chyba proste, prawda?

9.3.5. Sprawdzanie d┼éugo┼Ťci pliku

Aby sprawdzi─ç d┼éugo┼Ť─ç pliku, nale┼╝y wykorzysta─ç wiedz─Ö zdobyt─ů w dw├│ch poprzednich podrozdzia┼éach, tzn. najpierw trzeba przenie┼Ť─ç kursor na koniec pliku, a nast─Öpnie ÔÇ×spyta─çÔÇŁ strumie┼ä, gdzie jest kursor:

#include <iostream>
#include <fstream>
using namespace std;

int main()
{
    ifstream plik("C:/Nanoc/najlepszeWyniki.txt"); // Otwarcie pliku
    plik.seekg(0, ios::end); // Przej┼Ťcie na koniec pliku

    int dlugosc;
    dlugosc = plik.tellg();  // Sprawdzamy pozycj─Ö, kt├│ra odpowiada d┼éugo┼Ťci pliku!

    cout << "D┼éugo┼Ť─ç pliku w bajtach wynosi: " << dlugosc << "." << endl;

    return 0;
}

To wszystko, je┼Ťli chodzi o podstawowe wiadomo┼Ťci. Mo┼╝esz zacz─ů─ç zg┼é─Öbia─ç dalsze tajniki ┼Ťwiata plik├│w i j─Özyk├│w programowania.

Po przyswojeniu materia┼éu z tego rozdzia┼éu b─Ödziesz gotowy do rozpocz─Öcia poznawania bardziej zaawansowanych zagadnie┼ä i realizacji powa┼╝nych projekt├│w. Dobrze si─Ö sk┼éada, bo w nast─Öpnym rozdziale b─Ödziesz musia┼é wykona─ç praktyczny projekt, do kt├│rego realizacji b─Ödzie potrzebne wszystko to, czego nauczy┼ée┼Ť si─Ö do tej pory.

Zanim przejdziesz do tego projektu, przejrzyj jeszcze raz wszystkie zagadnienia, które do tej pory sprawiły Ci najwięcej problemów.

Autor: Mathieu Nebra i Matthieu Schaller

Źródło: http://openclassrooms.com/courses/programmez-avec-le-langage-c/lire-et-modifier-des-fichiers

Tłumaczenie: Łukasz Piwko

Tre┼Ť─ç tej strony jest dost─Öpna na zasadach licencji CC BY-NC-SA 2.0

3 komentarze do “Rozdzia┼é 9. Odczytywanie i zapisywanie plik├│w”

  1. Mo┼╝na przeskoczy─ç „kursorem” do nast─Öpnej linii zapisanego pliku, a nie na nast─Öpn─ů liter─Ö? Je┼Ťli tak to w jaki spos├│b?

    Pozdrawiam.

Mo┼╝liwo┼Ť─ç komentowania zosta┼éa wy┼é─ůczona.