Operacje na plikach w C Wprowadzenie Byo dane

Operacje na plikach w C++

Wprowadzenie • Było – dane są przechowywane w pamięci operacyjnej, programy także. • Wniosek – dane „żyją” tylko i wyłącznie w czasie pracy programu. Potem są nieodwołalnie usuwane. • Problem – co z danymi, których jest tak dużo, że nie warto ich wprowadzać za każdym uruchomieniem programu – np. dane PESEL, • Rozwiązaniem jest wykorzystanie plików.

Wprowadzenie • Co to jest plik? – Plik jest to zorganizowana struktura przechowywania informacji w sposób trwały. • Jaka jest organizacja pliku? – Fizyczna, – Logiczna. • Fizyczna nas (w tej chwili) nie interesuje - ścieżki, sektory, cylindry, rekordy (zazwyczaj 512 B) itd. • Logiczna – system plików i katalogów. • By w programowaniu korzystać z plików musimy orientować się w strukturze logicznej plików, czyli znać hierarchiczną strukturę plików na komputerze, na którym programujemy. • Hierarchiczna struktura plików to katalogi (katalog główny, bieżący, podkatalogi) i pliki w katalogach. • Katalog jest to taki plik, który może zawierać inne pliki.

Model pliku w programowaniu • W pewnym uproszczeniu każdy plik możemy wyobrazić sobie jako ciąg kolejnych elementów. Za ostatnim znajduje się znacznik końca pliku. • Element który zostanie przeniesiony z lub do RAM przy kolejnym odczycie lub zapisie wskazywany jest przez wskaźnik pliku stojący na początku tego elementu. • Wskaźnik końca może być realizowane na różne sposoby. Czasami jest to wyróżniona wartość (inna niż dowolna przechowywana w pliku informacja) zapisana na końcu pliku, a w innych rozwiązaniach informacja o końcu pliku zapisana jest w strukturze systemu zbiorów zwanej FAT (ang. file allocation table).

Typy plików • Ze względu na organizacje danych wewnątrz pliku (na poziomie logicznym), będziemy rozróżniać dwa typy plików: pliki binarne i pliki tekstowe.

Pliki tekstowe • Pliki tekstowe zasługują na szczególną uwagę, gdyż sposób kodowania informacji w tych plikach jest najbardziej rozpowszechnionym standardem, a także dlatego, że w wielu językach programowania stanowią one osobny wyróżniony typ danych z dodatkowym zestawem poleceń. • Plik tekstowy to ciąg znaków z podziałem na wiersze. Można powiedzieć, że podstawową jednostką danych w pliku tekstowym jest jeden znak, co w plikach zakodowanych w ASCII przekłada się na 1 bajt (nie zawsze). • Koniec wiersza kodowany jest na różne sposoby. Np. w systemie UNIX znak przejścia do nowego wiersza, a w systemie MS Windows koniec wiersza oznaczony jest dwoma znakami przejściem do nowego wiersza i powrotem karetki. • Są ważne.

Pliki binarne • Plik binarny to ciąg bajtów. • Inaczej można powiedzieć, że jest to plik, w którym rekord logiczny ma rozmiar jednego bajta. • Dane zawarte w pliku binarnym zawsze traktowane są jak ciąg bajtów, bez względu na rodzaj zapisanej w pliku informacji. • Każdy plik możemy potraktować jak plik binarny. • Musi być program, który te bajty interpretuje (w plikach tekstowych wszystkie bajty są znakami drukowalnymi (poza znakiem przejścia do nowego wiersza).

Rodzaje dostępu do pliku • Budowa pamięci masowej może też powodować ograniczenia w sposobie dostępu do poszczególnych części pliku. • Ze względu na te ograniczenia pliki możemy podzielić na: – pliki sekwencyjne, – pliki o dostępie bezpośrednim.

Pliki o dostępie sekwencyjnym • Pliki o dostępie sekwencyjnym charakteryzują się ograniczoną swobodą poruszania się po rekordach. • Aby przeczytać k-ty rekord trzeba przeczytać poprzedzające go k-1 rekordów. • Dodatkowo możemy przeskoczyć na początek albo na koniec pliku, ale nigdy w dowolne miejsce wewnątrz pliku.

Pliki o dostępie bezpośrednim • Pliki o dostępie bezpośrednim charakteryzują się tym, że rekordy logiczne są ponumerowane i można odczytywać je w dowolnym porządku dzięki operacji pozwalającej na przeskoczenie do rekordu o podanym numerze. • W tego rodzaju plikach wszystkie rekordy logiczne muszą mieć taki sam rozmiar. • Pliki o dostępie bezpośrednim realizuje się na takich urządzeniach, w których łatwo można się fizycznie dostać do dowolnego miejsca, niezależnie od jego położenia. Przykładami takich urządzeń są twarde dyski, pamięci flash.

Schemat przetwarzanie plików • • Otwarcie pliku, Operacje na danych w pliku, Zamknięcie pliku. Uwaga 1: w języku C++ za pracę z plikami odpowiada biblioteka fstream. Zawiera ona predefiniowane stałe i zdefiniowane funkcje ułatwiające operacje na plikach. • Uwaga 2: ważne typy danych związanych z plikami: – fstream – dowolny pliki, – ofstream – plik do zapisu, – ifstream – plik do odczytu.

Przykład #include <fstream> #include <iostream> using namespace std; int main(){ ofstream strumien; //definicja strumienia strumien. open("plik. txt"); //wskazanie pliku strumien << "Zapis do pliku"; //przeprowadzenie operacji (zapis) strumien. close(); //zamknięcie strumienia (następuje zapis do pliku, strumień jest buforowany) } Uwaga: Nie zamkniecie pliku może prowadzić do utraty danych. Dlaczego? – bo zapis jest buforowany.

Co trzeba zrobić, by pracować z plikami w C++ • Aby korzystać z plików należy dołączyć plik nagłówkowy fstream. h dyrektywą include: – #include <fstream> • Aby otworzyć plik do pisania, należy zdefiniować obiekt klasy ofstream (output file stream), np. – ofstream plikwy(”nazwapliku”, ios: : out); • Użyte argumenty oznaczają: – nazwapliku – nazwę pliku, – ios: : out – tryb otwarcia tego pliku. • Do odczytu to ios: : in • Innym trybem może być ios: : app – dla dodawania nowych elementów do pliku. • Gdy chcemy dopisywać nowe elementy, to należy użyć trybu ios: : app. • Gdy chcemy by plik był pusty po utworzeniu, to używamy ios: : trunc, • Typ pliku binarny to ios: : binary, a tekstowy to ios: : text.

Sprawdzenie, czy operacja otwarcia pliku się udała • Dobrym zwyczajem jest sprawdzenie (przed próbą pisania lub czytania), czy plik został pomyślnie otwarty. • Można to zrobić następująco: if (!plikwy) { // nie udało się otworzyć pliku cerr<<”nie można otworzyć pliku wyjściowego”; exit (-1); } • cerr jest standardowym urządzeniem na które są wysyłane komunikaty o błędach. Domyślnie jest to ekran (podobnie jak i cout). • Sprawdzać można także za pomocą funkcji: – good(); – is_open(); – Sa to funkcje, które zwracają prawdę lub fałsz

Przykład fstream plik; plik. open( "nazwa_pliku. txt", std: : ios: : in | std: : ios: : out ); if( plik. good() ) cout << "Uzyskano dostep do pliku! "; else cout << " Nie uzyskano dostepu ";

Przykład • Przykład programu pobierającego znaki ze standardowego strumienia wejściowego i wysyłającego do pliku kopia (domyślnym typem pliku jest plik tekstowy) #include <iostream> #include <fstream> main() { ofstream plikwy(”nazwapliku”, ios: : out); if (!plikwy) { // nie udało się otworzyć pliku cerr<<”nie można otworzyć pliku wyjściowego”; exit (-1); } char zn; while (cin. get(zn)) plikwy. put(zn); return 0; }

Czytanie z pliku • nazwa >> zmienna; //wczytanie zmiennej • getline( plik, dane ); //wczytanie wiersza • istream plik. getline( char * odczytane_dane, streamsize ilosc_danych, char znak_konca_linii ); Parametry oznaczają kolejno: – (odczytane_dane) wskaźnik zmiennej, do której mają zostać wczytane dane z pliku; – (ilosc_danych) maksymalna ilość znaków jakie mogą zostać zapisane do zmiennej; – (znak_konca_linii) parametr jest opcjonalny. Umożliwia zmianę znaku końca linii. • Przykład: – fstream plik( „dane. txt", ios: : in ); – char dane[ 255 ]; plik. getline( dane, 255 );

Czytanie blokowe z pliku • Czytanie blokowe z pliku jest bezpieczne dla typu binary. – istream plik. read( char * bufor, streamsize rozmiar_bufora ); • Bufor nie musi być wypełniony cały danymi. Do sprawdzenia, ile danych było w buforze służy funkcja gcount(), • Przykład: – fstream plik( "nazwa_pliku. txt", std: : ios: : in ); – char bufor[ 1024 ]; plik. read( bufor, 1024 ); – cout << "Wczytano " << plik. gcount() << " bajtów”;

Zapisywanie danych do pliku • ostream plik. write( const char *bufor, streamsize ilosc); fstream plik( "plik. txt", ios: : out ); string napis; getline(cin, napis ); plik. write( &napis[ 0 ], napis. length() ); //zapisuje //dane poczynając od 0 indeksu

Poruszanie się po pliku • Do tego celu służą funkcje seekg() i seekp() – seekg() ustawia wewnętrzny wskaźnik pliku dla funkcji odczytujących dane; – seekp() ustawia wewnętrzny wskaźnik pliku dla funkcji zapisujących dane. • Uzycie: – istream p. seekg( streamoff offset, ios_base: : seekdir kierunek ); ostream p. seekp( streamoff offset, ios_base: : seekdir kierunek ); • Dla kierunek sa możliwości: – ios_base: : beg - Przesunięcie względem początku pliku (domyślne) – ios_base: : cur - Przesunięcie względem aktualnej pozycji – ios_base: : end - Przesunięcie względem końca pliku

Poruszanie się po pliku • Aby sprawdzić, czy skok na nową pozycję zakończył się sukcesem możemy dokonać tego na dwa sposoby: – Sprawdzić aktualną pozycję pliku i porównać z tą, którą chcieliśmy otrzymać; – Wywołać funkcję fail(), należącą do klasy fstream. Jest ona postaci: fail(); i zwraca wartość logiczną. • Do testowania końca pliku służy funkcja plik. eof()

//-------------------------------------#include <conio. h> #include <iostream. h> #include <fstream. h> int main(int argc, char* argv[]) { ofstream zapis; ifstream odczyt; zapis. open("c: \plik 1. doc", ios: : out); if ( !zapis ) { cerr << "Nieudane otwarcie pliku do zapisun"; getch(); exit( 1 ); } zapis << "To jest pierwszy wiersz tekstu, n"; zapis << "a to drugi. n"; char napis[20]; cout<<"napis="; cin>>napis; zapis << napis; zapis. close(); odczyt. open("c: \plik 1. doc", ios: : in); char znak; while ((znak=odczyt. get())!=EOF) cout<<znak; cout<<"Koniec"; odczyt. close(); getch(); return 0; Przykład – czytanie znaków i wyrazów

#include <vcl. h> #include <iostream. h> #include <fstream. h> #include <conio. h> #pragma hdrstop #pragma argsused int main(int argc, char* argv[]) { float liczba=1. 0; fstream plik("c: \liczby. txt", ios: : in | ios: : out | ios: : trunc); while(true){ cout << "Podaj liczbe: "; cin >> liczba; if(liczba!=0) plik << liczba << " "; else break; } plik. close(); plik. open("c: \liczby. txt"); while(!plik. eof()){ plik>>liczba; if(!plik. fail()) cout<<liczba<<" "; //ostatnim znakiem jest spacja, wiec eof jest dopiero po spacji } plik. close(); cout<<endl; getch(); return 0; } Przykład – czytanie liczb • Uwaga: Funkcja int fail() - funkcja zwraca wartość niezerową np. gdy oczekujemy wartości liczbowej a otrzymamy tekst

Wszystkie tryby otwarcia pliku • app - otwarcie pliku do dopisywania, dane dołączane są do końca pliku. • ate - otwarcie pliku z ustawieniem wskaźnika plikowego na końcu pliku. • in - otwarcie pliku do odczytu (tryb domyślny klasy ifstream) • out - otwarcie pliku do zapisu (tryb domyślny klasy ofstream) • binary - otwarcie pliku w trybie binarnym. Pliki obsługiwane są za pomocą klas ifstream i ofstream otwierane są domyślnie w trybie tekstowym, • trunc - Otwarcie pliku ze zniszczeniem jego poprzedniej zawartości. Tryb ten jest domyślny, o ile nie został użyty specyfikator app lub ate.

Zapis do plików binarnych #include <iostream. h> #include <fstream. h> int main(int argc, char* argv[]) { struct firmy{ char* nazwa; float przychod; }; //zapis danych firmy firma; ofstream plik 1("dane. dat", ios: : binary | ios: : app| ios: : out); firma. nazwa="test"; firma. przychod=23; // zapis do pliku struktury firma przekonwertowanej (przeinterpretowanej) na ciąg znaków // ponieważ jest ios: : app to dopisujemy na końcu plik 1. write(reinterpret_cast<char*>(&firma), sizeof(firma)); plik 1. close(); plik. close(); getchar(); return 0; } //--------------------------------------

#include <iostream. h> #include <fstream. h> int main(int argc, char* argv[]) { struct firmy{ char* nazwa; float przychod; }; //odczyt danych int i=1; ifstream plik("dane. dat", ios: : binary| ios: : in); while (1) { // odczyt z pliku ciągu znaków i przekonwertowanie (przeinterpretowanie) na ciąg strukturę firma plik. read(reinterpret_cast<char*>(&firma), sizeof(firma)); //z plikiem związany jest znacznik pliku. Znacznik pliku może by na końcu, //ale funkcja eof() zwróci wartosc false. //Funkcja zwróci wartosc true gdy znacznik jest na końcu pliku i jeszcze cos czytamy. if(plik. eof()) break; //tu jestesmy, gdy czytanie powiodło się, więc to co przeczytalismy wypisujemy. cout<<i<<" "<<firma. nazwa<<" "<<firma. przychod<<endl; i++; } Odczyt danych z pliku binarnego plik 1. close(); plik. close(); getchar(); return 0; }

Operator reinterpret_cast • Zapis <T> oznacza szablon – jest to pojecie z programowania obiektowego. • reinterpret_cast< T > (arg) to operator, którego celem jest konwersja przez zamianę typów, które są niepewne (nie mamy pewności co do konwersji niejawnej dokonanej przez kompilator) lub zależne od implementacji. • W deklaracji, reinterpret_cast< T > (arg) , T musi być wskaźnikiem, referencją, typem arytmetycznym, wskaźnikiem na funkcję lub wskaźnikiem na element. • Wskaźnik może być całkowicie przekonwertowany na typ wbudowany. • Wbudowany arg może być przekonwertowany na wskaźnik. Konwersja wskaźnika na typ wbudowany i na odwrót na ten sam typ wskaźnikowy dostarcza oryginalną wartość. • Możliwe jest użycie do konwersji jeszcze nie zdefiniowanej klasy wskaźnika lub referencji. • Wskaźnik na funkcje może być poprawnie przekonwertowany na wskaźnik na obiekt pod warunkiem, że dostarczany wskaźnik na obiekt, posiada wystarczającą ilość bitów do przechowania wskaźnika na funkcję. Wskaźnik na obiekt może być poprawnie przekonwertowany na wskaźnik na funkcję tylko jeśli wskaźnik na funkcję jest wystarczająco duży aby przechować wskaźnik na obiekt.

Modyfikacja danych w pliku binarnym • Algorytm: – Ustawiamy się przed rekordem, który chcemy zmodyfikować za pomocą polecenia: • plik 1. seekp(sizeof(struct firmy)*(k-1)); – Odczytujemy rekord (polecenie read), – Ustawiamy poprawne dane, – Zapisujemy rekord (polecenie write).

Usunięcie wybranego rekordu • Rozwiązanie z wykorzystaniem pomocniczego pliku: – określamy, który rekord chcemy usunąć, niech będzie to rekord o numerze k, – Przepisujemy wszystkie rekordy od numeru 0 do numeru k-1, – Wczytujemy rekord o numerze k (nie przepisujemy go), – Przepisujemy pozostałe rekordy o numerach k+1 do końca, – Zamykamy pliki (mamy poprawne dane w tymczasowym i oryginalny zawiera wszystkie rekordy), – Otwieramy oryginalny i czyścimy go (trunc), – Przepisujemy wszystkie rekordy z pliku tymczasowego do oryginalnego, – Usuwamy dane z tymczasowego.

Pliki jako parametry funkcji main • • Nagłówek funkcji głównej: – – – int main(int argc, char* argv[]); argc – liczba argumentów, argv[] – tablica argumentów. Przykładowy program: #include <fstream. h> int main(int argc, char* argv[]) { char znak; if(argc != 2) { cerr <<”Napisz: czytaj <nazwa-pliku>n”; return 1; } ifstream plik=open(argv[1]); if(!plik) { cerr <<”Nieudane otwarcie pliku do odczytun�”; return 1; } while(!plik. eof()) { plik. get(znak); cout << znak; } return 0; }