fstream C/C++ #include <fstream> Stream strumień plików std::ifstream C/C++ uchwytem do pliku uchwyt do pliku plik std::ifstream

Transkrypt

1 Podstawy obsługi plików Wykład ze strony: [lekcja] Rozdział 32. W rozdziale opisano podstawową obsługę plików, tj. w jaki sposób otwiera się pliki, jak sprawdzić czy otwarcie pliku się powiodło, jak należy zamykać pliki oraz w jaki sposób można wczytać zawartość pliku tekstowego przy pomocy funkcji std::getline. Wprowadzenie Każdorazowe wprowadzanie danych do utworzonego programu jest użyteczne, jednak w większości przypadków jest to po prostu niepraktyczne. Każda komercyjna gra jak i każda aplikacja korzysta z możliwości odczytywania i zapisywania danych. Nawet w najprostszych grach wykorzystuje się pliki do zapamiętywania najlepszych osiągniętych wyników bądź do zapisywania konfiguracji klawiszy, umożliwiających sterowanie grą. W niniejszym rozdziale nauczysz się w jaki sposób można odczytywać tekst umieszczony w pliku tekstowym. Dostępne narzędzia do obsługi plików Dostęp do plików można uzyskać na wiele sposobów. Jeżeli programujesz pod Windowsem, możesz użyć funkcji należących do biblioteki WinAPI. Jeżeli nie chcesz uzależniać się od systemu operacyjnego, możesz użyć funkcji wywodzących się ze standardu C, bądź skorzystać z pakietu narzędzi jakie pojawiły się wraz ze standardem C++. Czego używać najlepiej? Trudno powiedzieć. Programiści wytwarzający aplikacje tylko i wyłącznie pod Windowsa korzystają zazwyczaj z niskopoziomowych funkcji WinAPI. W wielu programach pisanych pod Linuksa wykorzystywane są funkcje dostarczone wraz ze standardem C, co wynika w dużej mierze z zaszłości historycznych. Narzędzia, które pojawiły się wraz ze standardem C++ są jednak całkiem wygodne i również mają swoje grono zwolenników. Ponieważ niniejszy kurs jest poświęcony nauce C++ to rozdział ten będzie omawiał obsługę plików w oparciu o narzędzia dostarczone wraz ze standardem C++. Biblioteka do obsługi plików Po całkiem długim wprowadzeniu, czas przejść do omawiania obsługi plików. Aby mieć możliwość korzystania z narzędzi do obsługi plików, dostarczonych wraz ze standardem C++, należy na początku kodu źródłowego dołączyć odpowiedni plik nagłówkowy. Jeżeli w naszej aplikacji będziemy chcieli odczytywać lub zapisywać pliki to wystarczy, że dołączymy plik nagłówkowy fstream, czyli: #include <fstream> Nazwa pliku jest łatwa do zapamiętania, ponieważ jest to skrót z angielskiego tj. od File Stream, co po przetłumaczeniu na nasz język oznacza strumień plików. Uchwyt do obsługi pliku Kolejnym etapem jest utworzenie obiektu, który umożliwi nam komunikację ze wskazanym przez nas plikiem. Obiekt ten tworzy się analogicznie do zmiennych. Typem danych będzie teraz std::ifstream, natomiast nazwa zmiennej może być dowolna, przykładowo: std::ifstream plik; Teraz za pomocą zmiennej plik możemy komunikować się z dowolnym plikiem znajdującym się na dysku. Należy mieć jednak świadomość, że klasa std::ifstream posiada tylko i wyłącznie metody umożliwiające odczytywanie zawartości pliku, co akurat jest dla Ciebie w chwili obecnej bardzo korzystne, ponieważ nie nadpiszesz sobie niechcący zawartości odczytywanego pliku i jednocześnie będziesz mógł się oswoić z jego obsługą. Warto również wiedzieć, że zmienna za pomocą której można dostać się do danych pliku zazwyczaj nazywana jest uchwytem do pliku. W przypadku obsługi plików przy pomocy funkcji należących do standardu C (lub funkcji biblioteki WinAPI) nazwa uchwyt do pliku jest jak najbardziej poprawna. W przypadku stosowania standardu C++ jest to lekkim nadużyciem, bowiem zmienna plik jest w rzeczywistości obiektem, wewnątrz którego znajduje się uchwyt do pliku. Nie do końca to rozumiesz? Obecnie nie musisz :) Gdy zaczniesz się uczyć programowania obiektowego to wszystko stanie się jasne. W każdym razie jeżeli zmienna typu std::ifstream zostanie nazwana uchwytem do pliku to należy traktować to jako duży skrót myślowy, ułatwiający komunikację, a nie jako precyzyjne sformułowanie.

2 Otwieranie wybranego pliku Mając utworzony już 'uchwyt' do pliku, wystarczy teraz wskazać jaki plik na dysku chcielibyśmy otworzyć do odczytu. Czynność tą wykonuje się przy pomocy metody open, gdzie pierwszym argumentem metody jest ścieżka do pliku, który chcielibyśmy otworzyć. Załóżmy więc, że mamy na dysku C:\ plik, który nosi nazwę "odczyt.txt". Otworzenie wspomnianego pliku sprowadzi się więc do następujących linijek: std::ifstream plik; plik.open( "C:\\odczyt.txt" ); Jeżeli wspomniany plik będzie istniał na dysku oraz nie będzie on zablokowany do odczytu przez inną aplikację, to wówczas otwarcie pliku zakończy się powodzeniem. Ścieżka do pliku Stosunkowo nudną, ale bardzo cenną informacją jest znajomość prawidłowego zapisu ścieżek do pliku w językach C i C++ oraz zdobycie wiedzy, w jaki sposób są obsługiwane ścieżki przez system operacyjny. Ścieżki względne i ścieżki bezwzględne Ścieżki do pliku mogą być względne oraz bezwzględne. Ścieżka względna to taka, która nie zawiera pełnej ścieżki do pliku, tj. nie rozpoczyna się ona od litery (czy też nazwy) dysku. Tym samym ścieżką względną będzie np. podanie samej nazwy pliku (wraz z jego rozszerzeniem!), bądź podanie ścieżki względem katalogu roboczego aplikacji. Ścieżka bezwzględna określa natomiast pełną ścieżkę do pliku i zaczyna się od litery (nazwy) dysku, a kończy się na pełnej nazwie pliku. Informacja Stwierdzenie 'litera dysku' dotyczy systemu Windows, natomiast stwierdzenie 'nazwa dysku' dotyczy sytemu Linuks. Katalog roboczy Katalog roboczy jest to katalog od którego rozpoczyna się poszukiwanie pliku na dysku w przypadku, gdy podana ścieżka do pliku jest ścieżką względną. Katalogiem roboczym zazwyczaj jest katalog, w którym znajduje się uruchamiany plik *.exe. Katalog roboczy może być jednak inny, niż katalog w którym znajduje się plik *.exe, co bardzo często uprzykrza życie początkującym programistom, którzy stwierdzają, że: 'plik jest na dysku, ścieżka względna jest podana poprawnie, a pliku otworzyć się nie da'. Należy więc mieć świadomość, że katalog roboczy może być inny niż katalog, w którym znajduje się plik *.exe w sytuacji, gdy: aplikacja jest uruchamiana za pomocą wiersza poleceń poprzez podanie ścieżki bezwzględnej do aplikacji; aplikacja jest uruchamiana za pomocą wiersza poleceń poprzez podanie ścieżki względnej, wskazującej na aplikację znajdującą się w innym katalogu niż katalog widoczny w wierszu poleceń; aplikacja jest uruchamiana przez środowisko programistyczne (w każdym szanującym się środowisku programistycznym istnieje możliwość ustawiania katalogu roboczego dla uruchamianej aplikacji); do utworzonej aplikacji utworzono skrót, w którym zdefiniowano ustawianie innego katalogu roboczego niż domyślny; uruchamiana aplikacja samodzielnie zmienia katalog roboczy, bo tak została zaprogramowana przez programistę. Ostatni przypadek dotyczy programistów działających świadomie, natomiast cała reszta jest źródłem wielu problemów dla osób posiadających niewielką wiedzę z zakresu działania różnych mechanizmów w systemach operacyjnych. Ścieżka do pliku, a znak backslash '\\' Jak już zapewne zauważyłeś, podczas podawania ścieżki do pliku został użyty dwukrotnie znak backslasha (czyli znak \ ). Podając znaki, bądź łańcuchy znaków w języku C++ należy pamiętać, że backslash jest znakiem specjalnym, który umożliwia łatwe wstawienie chociażby znaku nowej linii. Tym samym zapisanie pojedynczego backslasha do zmiennej tekstowej (bądź do zmiennej znakowej) wymaga napisania dwóch znaków '\\'. Początkowi programiści prawie zawsze o tym zapominają, a potem godzinami wpatrują się w kod źródłowy szukając błędu wszędzie, tylko nie w podanej ścieżce do pliku. Wniosek? Zapamiętaj ten fakt! :)

3 Slashe i backslashe w ścieżce do pliku Innym, znacznie lepszym rozwiązaniem jest podawanie w ścieżkach slashy (znak /) zamiast backslashy (znak \). Slashe jak również backslashe są traktowane jako znaki równoważne w ścieżkach do plików, ale dla programistów C++ znak slasha jest znacznie wygodniejszy, bowiem nie jest on znakiem specjalnym, a zatem nie trzeba pamiętać o wspomnianym wcześniej technicznym szczególe i tym samym dużo trudniej popełnić ewentualny błąd przy podawaniu ścieżki. Ścieżki do plików - podsumowanie Podając ścieżki do plików warto używać slashy zamiast backslashy. Pamiętaj również, że jeżeli nie możesz otworzyć pliku podając ścieżkę względną, winę może ponosić ustawiony katalog roboczy - wówczas warto spróbować podać ścieżkę bezwzględną w aplikacji, aby mieć pewność, że problem faktycznie dotyczył tylko i wyłącznie właściwego ustawienia katalogu roboczego. Sprawdzenie czy udało się otworzyć plik Powróćmy teraz do właściwej nauki obsługi plików. Otworzenie pliku może zakończyć się zarówno powodzeniem jak i fiaskiem. Czynników wpływających na sukces bądź porażkę otwarcia pliku jest wbrew pozorom wiele, a więc zanim zaczniesz wykonywać jakiekolwiek operacje na pliku, warto upewnić się, że faktycznie udało się uzyskać do niego dostęp (czyli udało się otworzyć plik). Do tego celu używa się zazwyczaj metody good, należącej do klasy std::ifstream. Linijka za pomocą której możemy sprawdzić czy udało się otworzyć plik, może wyglądać następująco: if( plik.good() ) //INFO: plik udało się otworzyć else //INFO: otwarcie pliku się nie powiodło //else Odczytywanie tekstu z pliku Zaletą narzędzi C++ jest niewątpliwie łatwość ich używania. Odczytywanie tekstu z pliku sprowadza się bowiem do użycia strumienia >>, bądź zastosowania znanej już Ci funkcji std::getline, która została omówiona w rozdziale» Kurs C++» Poziom 3 Wczytywanie tekstu - standardowy strumień wejścia lekcja. W związku z tym, że zasada działania wspomnianej funkcji została już omówiona we wspomnianym wyżej rozdziale, to jej zachowanie nie będzie ponownie omawiane. Zamiast tego omówię jak należy używać funkcji std::getline do pracy z otwartym plikiem: std::string odczytanytekst std::getline( plik, odczytanytekst ); Powyższy zapis wczytuje jeden wiersz z pliku, którego 'uchwyt' został podany poprzez pierwszy argument omawianej funkcji, natomiast wczytana treść zostanie zapisana do zmiennej odczytanytekst. W tym miejscu warto również wspomnieć, że wywołanie powyższego polecenia nie gwarantuje nam odczytania tekstu. Wczytanie kolejnego wiersza tekstu zakończy się niepowodzeniem, gdy w pliku nie będzie więcej tekstu do odczytania. Odczyt może zakończyć się również niepowodzeniem w wyniku innych czynników, takich jak np. awaria urządzenia (np. wysunięto płytę CD, z której odczytywaliśmy zawartość pliku). W dużym uproszczeniu możesz przyjąć, że funkcja std::getline zwraca wartość logiczną true w przypadku sukcesu, natomiast false w przypadku niepowodzenia. Tym samym, możesz napisać odczytywanie zawartości całego pliku w następujący sposób: std::string wiersz; for( bool bwczytano = std::getline( plik, wiersz ); bwczytano; bwczytano = st d::getline( plik, wiersz ) ) std::cout << wiersz << std::endl;

4 Inny sposób odczytania zawartości całego pliku został zawarty w przykładzie, który znajduje się w dalszej części niniejszego rozdziału. Uwaga! Funkcja std::getline w rzeczywistości nie zwraca wartości logicznej. Rzeczywisty mechanizm, który jest odpowiedzialny za zwracaną wartość wspomnianej funkcji jest jednak na tyle trudny do omówienia w jasny sposób, że na obecnym poziomie Twojej wiedzy lepiej pozostać przy zastosowanym w treści uproszczeniu. Inne metody odczytywania zawartości pliku tekstowego Inne metody odczytywania zawartości pliku tekstowego zostaną omówione w kolejnym rozdziale, w tym również wspomniany odczyt tekstu za pomocą strumienia >>. Zamykanie otwartego pliku Skoro już wiesz jak otworzyć plik oraz odczytać z niego informacje, wypadałby również wiedzieć w jaki sposób należy go zamknąć. Wiedz, że każdy otwarty plik należy zamykać zaraz po zakończeniu z nim pracy. Do tego celu służy metoda close, której wywołanie wyglądać może następująco: plik.close(); Przykład A teraz część praktyczna :) Przykład prezentujący w jaki sposób odczytuje się zawartość pliku tekstowego został zaprezentowany poniżej. Do prowadzenia eksperymentów z odczytywaniem pliku warto mieć przygotowany jakiś plik tekstowy. Żeby Ci ułatwić naukę, utworzyłem krótki plik tekstowy, który możesz teraz pobrać i zapisać w stosownym katalogu na dysku (plik: cpp0x.txt). #include <fstream> #include <iostream> bool wyswietlzawartoscpliku( std::string snazwapliku ) std::ifstream plik; plik.open( snazwapliku.c_str() ); if(!plik.good() ) return false; std::string wiersz; while( std::getline( plik, wiersz ) ) std::cout << wiersz << std::endl; plik.close(); return true; int main() if(!wyswietlzawartoscpliku( "cpp0x.txt" ) ) std::cout << "Nie udalo sie otworzyc pliku o podanej nazwie." << std::endl; return 0; Jeżeli skorzystałeś z pliku tekstowego, wspomnianego w niniejszym kursie, to wówczas w oknie konsoli powinieneś zobaczyć następującą treść: --==[ Kurs C++ ]==--

5 Obecnie uczysz sie obslugi plikow. Link do czytanego rozdzialu: Udalo Ci sie odczytac plik? Wykonaj teraz prace domowa ze wspomnianego rozdzialu! :) Podsumowanie Po ukończeniu tego rozdziału powinieneś wiedzieć jak otworzyć plik tekstowy, jak odczytać jego zawartość oraz jak prawidłowo należy kończyć z nim pracę. Jeżeli uważasz, że zrozumiałeś treść całego niniejszego rozdziału, zachęcam Cię do próby samodzielnego rozwiązania pracy domowej. Zadanie domowe Napisz program, który odczyta zawartość pliku, a następnie wypisze na ekranie tylko te wiersze, w których znajduje się wyraz wprowadzony przez użytkownika. Wczytywanie danych z pliku za pomocą operatora >> [lekcja] Rozdział 33. Odczytywanie zawartości pliku tekstowego za pomocą operatora >>. Wprowadzenie Wczytywanie zawartości plików tekstowych przy pomocy funkcji std::getline jest zazwyczaj satysfakcjonującym rozwiązaniem, jednak nie zawsze jest ono wygodne. Dane w pliku czasami są zapisane w postaci liczb, a te z kolei chcielibyśmy wczytywać od razu do zmiennych liczbowych, oszczędzając sobie tym samym problemów związanych z wyciąganiem ich ze zmiennej tekstowej. W niniejszym rozdziale poznasz rozwiązanie, które umożliwi Ci łatwe wczytywanie liczb z pliku tekstowego. Odczytywanie danych za pomocą operatora >> Zanim rozpoczniemy wykonywać jakiekolwiek działania na pliku, należy go uprzednio otworzyć. Jak już wiesz, plik w trybie do odczytu można otworzyć następująco: std::ifstream plik; plik.open( "nazwa-pliku.txt" ); Jeżeli otwarcie pliku zakończyło się powodzeniem, to możemy odczytywać już z niego interesujące nas dane. Dane z pliku można odczytywać na wiele sposobów, jednak aktualnie zajmiemy się operatorem >>. Operator >> umożliwia wczytywanie danych do zmiennych w taki sam sposób, w jaki wczytywaliśmy dane wprowadzane przy pomocy klawiatury. Tym samym napisanie: int zmienna; plik >> zmienna; spowoduje, że z pliku wczytana zostanie liczba do podanej przez nas zmiennej. Jeżeli zmienna w powyższym przykładzie będzie typu float to operator >> będzie umiał wczytać liczbę zmiennoprzecinkową. Jeżeli zmienna będzie typu std::string to wówczas operator >> wczyta jeden wyraz z pliku. Jeżeli zmienna będzie typu char to wówczas odczytany zostanie jeden znak, który nie jest białym znakiem. Pamiętaj, że operator >> zawsze pomija wszelkie napotkane białe znaki. Co to jest biały znak? Białymi znakami są nazywane te symbole, które są używane w tekście i nie posiadają swojej reprezentacji graficznej. Przykładem takiego znaku jest spacja, tabulacja czy też znak przejścia do nowej linii (enter). Wykaz białych znaków znajdziesz w opisie funkcji» standard C isspace za pomocą której możesz stwierdzić czy znak o podanym kodzie ASCII zalicza się do białych znaków. Przykład Załóżmy, że mamy plik, w którym dane mamy zapisane następująco:

6 10 dodac 5 3 odjac 2 77 zonk 3 99 dodac 1 Jak nietrudno zauważyć, w każdym wierszu podanego pliku znajduje się liczba, później wyraz i ponownie liczba. Taki plik możemy sobie w łatwy sposób wczytać przy pomocy operatora >>, a następnie wykonać na nim jakieś operacje, np. operacje matematyczne. Poniższy kod prezentuje w jaki sposób można wczytać powyższy plik oraz jak wykonywać na nim operacje. Kod źródłowy: #include <fstream> #include <iostream> #include <string> void wykonajoperacje( int liczba1, std::string napis, int liczba2 ) if( napis == "dodac" ) std::cout << liczba1 << " + " << liczba2 << " = " << liczba1 + liczba2 << std::endl; else if( napis == "odjac" ) std::cout << liczba1 << " - " << liczba2 << " = " << liczba1 - liczba2 << std::endl; else std::cout << "Nieznana operacja \"" << napis << "\" - nie mozna wykonac obliczen." << std::endl; bool wczytajplik( std::string nazwapliku ) std::ifstream plik; plik.open( nazwapliku.c_str() ); if(!plik.good() ) return false; while( true ) //pętla nieskończona int a; std::string b; int c; plik >> a >> b >> c; if( plik.good() ) wykonajoperacje( a, b, c ); else break; //zakończ wczytywanie danych - wystąpił jakiś błąd (np. nie ma więcej danych w pliku) //while return true; int main()

7 if(!wczytajplik( "dane.txt" ) ) std::cout << "Nie udalo sie otworzyc pliku!" << std::endl; return 0; W wyniku działania powyższego programu, na standardowym wyjściu pojawią się następujące komunikaty: = = 1 Nieznana operacja "zonk" - nie mozna wykonac obliczen = 100 Podsumowanie W niniejszym rozdziale dowiedziałeś się, w jaki sposób można wczytywać dane z pliku przy pomocy operatora >>. W kolejnym rozdziale zajmiemy się obsługą błędów, jakie mogą wystąpić podczas wczytywania danych. Zadanie domowe Otwórz plik tekstowy, w którym będą znajdowały się tylko liczby całkowite, oddzielone od siebie spacjami. Następnie napisz program, który wczyta wszystkie liczby z pliku i wypisze sumę wszystkich liczb na standardowym wyjściu. Wczytywanie zawartości pliku, a kontrola błędów [lekcja] Rozdział 34. Omówienie dostępnych mechanizmów do kontroli błędów podczas wczytywania zawartości pliku oraz przedstawienie kilku sposobów na radzenie sobie z nimi. Wprowadzenie Najtrudniejszym elementem w dziedzinie wytwarzania oprogramowania jest zapewnienie właściwej obsługi błędów w powstającej aplikacji. Programista tworzący kod musi bowiem z pełną świadomością pisać każdą linijkę kodu, zadając sobie przy tym różne pytania związane z jego bezpieczeństwem. Oto kilka przykładowych pytań pojawiających się każdego dnia w pracy programisty: "Czy tworzony fragment kodu może zadziałać źle dla skrajnie niepoprawnych danych wejściowych?"; "Jak powinien zachować się fragment kodu w przypadku niepoprawnych danych?"; "Czy analizowany fragment kodu prawidłowo obsłuży wszystkie nieoczekiwane błędy?". Z czasem pojawią się również inne pytania: "Jak pisać bezpieczny kod?"; "Jak zabezpieczyć się przed występowaniem błędów w kodzie?"; "Czy da się automatycznie testować poprawność działania kodu?". Choć powyższe pytania pozostaną na chwilę obecną bez odpowiedzi, to mimo wszystko warto zacząć zwracać szczególną uwagę na wszelkie problemy związane z bezpieczeństwem i obsługą błędów. Pomimo, iż aspekty związane z wytwarzaniem bezpiecznego kodu są miejscami bardzo ciekawe, to teraz musimy wrócić do właściwej części rozdziału. W niniejszej lekcji skoncentrujemy się na zagadnieniach związanych z obsługiwaniem błędów, jakie mogą się pojawić podczas pracy z plikami. Pliki, a narzędzia do kontroli błędów Pracując z plikami w trybie do odczytu kontroluje się przede wszystkim dane, które się z nich odczytuje. W idealnym przypadku dane w plikach są zawsze poprawne, ponieważ pliki używane przez własne programy zazwyczaj są stworzone przez nas samych. Problem zaczyna się pojawiać wtedy, gdy użytkownik aplikacji będzie mógł samodzielnie przygotować plik z danymi, a te z kolei mogą okazać się niekoniecznie poprawne dla Twojego programu. Z pomocą przychodzą nam wówczas takie metody jak eof, good, bad, fail oraz clear, należące do znanej już Ci klasy ifstream.

8 Metoda ifstream::eof Metoda eof, należąca do klasy std::ifstream zwraca prawdę, jeżeli ostatnio wykonana operacja odczytu danych została zakończona z powodu osiągnięcia końca pliku. Informację tą bardzo często wykorzystuje się wtedy, gdy chcemy odczytać zawartość całego pliku nie wiedząc ile danych się w nim znajduje. Przykład: while(!plik.eof() ) std::string swiersz; std::getline( plik, swiersz ); //odczytujemy wiersz z pliku Metoda ifstream::bad Metoda bad należy również do klasy std::ifstream. Zwraca ona prawdę, jeżeli ostatnio wykonana operacja odczytu danych zakończy się niepowodzeniem z powodu wystąpienia błędu sprzętowego. Przez błąd sprzętowy należy rozumieć pojawienie się badsectorów na dysku, niedostępność urządzenia na którym znajdował się otwarty plik (np. pendrive lub dysk sieciowy) lub zabranie dostępu do pliku przez inny proces. Przykład: bool odczytajplik( std::string snazwapliku ) std::ifstream plik; plik.open( snazwapliku.c_str() ); if(!plik.good() ) return false; //Nie udało się otworzyć pliku while(!plik.eof() ) std::string swiersz; std::getline( plik, swiersz ); if( plik.bad() ) //podczas próby odczytania danych wystąpił błąd sprzętowy plik.close(); return false; //wychodzimy z funkcji i informujemy, że odczytanie pliku zakończyło się niepowodzeniem std::cout << swiersz << std::endl; plik.close(); return true; Metoda ifstream::fail Metoda fail zwróci prawdę, gdy odczytanie danych zakończy się niepowodzeniem z powodu wystąpienia błędu sprzętowego lub z powodu błędu logicznego jaki miał miejsce podczas odczytu danych. Przez błąd logiczny odczytu danych należy rozumieć sytuację, w której aplikacja została zaprogramowana tak, aby odczytywała liczby, natomiast w pliku znalazły się również inne znaki np. nieoczekiwane litery alfabetu bądź znaki specjalne. int iliczba; plik >> iliczba; if( plik.fail() ) std::cout << "Nie udalo sie wczytac liczby!" << std::endl;

9 Metoda ifstream::good Metoda good zwraca prawdę wtedy, gdy strumień danych jest w prawidłowym stanie tj. żaden błąd nie wystąpił podczas pracy z plikiem. Wspomnianą metodę warto wykorzystywać przede wszystkim do sprawdzania, czy otwarcie pliku zakończyło się powodzeniem. Przykład: std::ifstream plik; plik.open( "plik.txt" ); if( plik.good() ) std::cout << "Plik zostal otwarty" << std::endl; else std::cout << "Nie udalo sie otworzyc pliku" << std::endl; Metoda ifstream::clear Funkcje jak również metody do odczytu danych z pliku działają tylko wtedy, gdy strumień danych jest w poprawnym stanie. Jeżeli w trakcie pracy z plikiem wystąpił jakikolwiek błąd (tj. napotkano koniec pliku, wystąpił błąd logiczny lub sprzętowy, albo nie udało się otworzyć pliku do odczytu), to wówczas kontynuowanie pracy z obiektem std::ifstream nie będzie możliwe. Aby móc wznowić pracę ze strumieniem, należy skorzystać z metody clear, która czyści tzw. flagi błędów. Przykład: while(!plik.eof() ) int iliczba; plik >> iliczba; //Wczytujemy liczbę if( plik.fail() ) std::cout << "Nie udalo sie wczytac liczby!" << std::endl; plik.clear(); //Czyścimy flagi błędów char cznak; plik >> cznak; //Wczytujemy znak if( plik.fail() ) break; //Nie udało się wczytać znaku - wychodzimy z pętli (jeden znak zawsze powinno dać się odczytać jeżeli plik działa prawidłowo i nie napotkaliśmy końca pliku) else std::cout << "Napotkano znak '" << cznak << "'" << std::endl; else std::cout << "Liczba = " << iliczba << std::endl; Flagi w programowaniu Czym są flagi błędów? Flagi są to w dużym uproszczeniu zmienne, które przechowują informacje o stanie obiektu. Jedna flaga opisuje jeden stan i może przyjmować tylko dwie wartości tj. zero lub jeden. Wartość 'jeden' można utożsamiać z wartością true, choć znacznie częściej mówi się, że flaga jest ustawiona. Analogicznie jest z wartością 'zero', którą utożsamia się z wartością false i wówczas mówi się, że dana flaga nie jest ustawiona. Flagi błędów można więc wyobrazić sobie jako zmienne, które przechowują informacje o błędach jakie wystąpiły podczas używania pliku. Flagi błędów już poznałeś, jednak nie zostały one do tej pory tak nazwane. Jedna flaga błędów przechowuje jedną informację - np. czy napotkano koniec pliku podczas odczytywania danych czy też nie. Kolejna flaga błędów zawiera informację o tym, czy wystąpił błąd sprzętowy podczas odczytu pliku. Trzecia flaga i czwarta flaga również jest Ci już znana i jak zapewne się domyślasz dotyczy ona metod fail orazgood. Na Twoim poziomie wiedzy flagi mógłbyś wyobrazić sobie tak:

10 bool bflagafail = false; bool bflagabad = false; bool bflagaeof = false; bool bflagagood = true; Tym samym, w przypadku napotkania końca pliku podczas odczytywania danych, ustawiana jest flaga bflagaeof = true, dzięki czemu możemy później poznać przyczynę zakończenia odczytywania danych z pliku. Czyszczenie flag błędów Przez czyszczenie flag błędów należy rozumieć przywracanie ich wartości do stanu domyślnego. Stanem domyślnym nie musi być wcale wartość false, czego najlepszym przykładem jest flaga informująca o tym, czy strumień ifstream znajduje się w poprawnym stanie (czyli omówiona wcześniej metoda good). Flagi, a ich reprezentacja w pamięci Bardzo ważną cechą flag jest to, że można ich stan przechowywać na jednym bicie. Wspomnianą własność wykorzystuje się do zapisywania w jednej zmiennej kilku różnych informacji, dzięki czemu aplikacja zajmuje mniej miejsca w pamięci. Widząc pojęcie flag w kontekście programowania powinieneś wiedzieć, że chodzi o jedną zmienną, która przechowuje wiele flag, gdzie każda flaga oznacza jedną, konkretną informację. Przykładowo zmienna typu char zajmuje jeden bajt, a bajt składa się z 8 bitów, więc na jednym bajcie można przechować aż 8 flag. Do tego celu wykorzystuje się operacje bitowe, które w odpowiednim momencie zostaną omówione, jednak na chwilę obecną na tym się kończy teoria związana z flagami. Stosowane techniki obsługi błędów Poznałeś już narzędzia umożliwiające kontrolowanie poprawności wczytywanych danych. Warto również w tym rozdziale dowiedzieć się czegoś więcej, tj. jak wykorzystuje się poznane mechanizmy do kontroli błędów. Generalnie rzecz biorąc można wyróżnić trzy podejścia obsługi plików: Jeżeli podczas wczytywania pliku napotkamy jakikolwiek błąd to kończymy wczytywanie plików i informujemy użytkownika o niepowodzeniu (np. "błędny format danych pliku - wczytywanie danych zakończyło się niepowodzeniem"); Jeżeli wczytanie pliku zakończyło się niepowodzeniem, to informujemy użytkownika o miejscu wystąpienia błędu w pliku (np. "wystąpił błąd w wierszu 13, kolumna 15 - oczekiwano znaku '(', a napotkano znak ''"); Trzecie podejście polega na ignorowaniu błędnych wierszy z danymi i odczytywaniu wszystkiego co się da w sposób poprawny (takie podejście się przydaje w przypadku, gdy plik uległ częściowemu nadpisaniu i próbujemy odzyskać maksymalną ilość utraconych danych). Każde z powyższych podejść ma swoje zalety i wady. Najczęściej spotykanym rozwiązaniem jest podejście pierwsze tj. albo się uda wczytać wszystkie dane albo użytkownik jest informowany o wystąpieniu błędu i wówczas żadne dane nie są wyświetlane na ekranie. Takie rozwiązanie jest praktyczne i najmniej czasochłonne, więc do większości pisanych aplikacji warto stosować właśnie to podejście. Przykład Czas podsumować wiedzę zdobytą w niniejszym rozdziale w postaci trochę większego programu. Oto on: #include <string> #include <fstream> #include <iostream> bool wczytajliczbe( std::ifstream & plik, int & iliczba ) plik.clear(); //Wyczyszczenie ewentualnych flag błędów plik >> iliczba; if( plik.bad() )

11 std::cout << "Wystapil blad sprzetowy!" << std::endl; plik.close(); return false; else if( plik.fail() ) std::cout << "Nie udalo sie wczytac liczby!" << std::endl; return false; else std::cout << "Liczba = " << iliczba << std::endl; return true; bool wczytajznak( std::ifstream & plik, char & cznak ) plik.clear(); //Wyczyszczenie ewentualnych flag błędów plik >> cznak; if( plik.bad() ) std::cout << "Wystapil blad sprzetowy!" << std::endl; plik.close(); return false; else if( plik.fail() ) std::cout << "Nie udalo sie wczytac znaku!" << std::endl; return false; //if return true; bool odczytajplik( std::string snazwapliku ) std::ifstream plik; plik.open( snazwapliku.c_str() ); if(!plik.good() ) std::cout << "Nie udalo sie otworzyc pliku." << std::endl; return false; //if while(!plik.eof() ) int iliczba; char cznak; if(!wczytajliczbe( plik, iliczba ) && plik.bad() ) return false; //wczytanie liczby nie powiodło się z powodu błędu sprzętowego else if(!wczytajznak( plik, cznak ) ) if( plik.bad() ) return false; //wczytanie liczby nie powiodło się z powodu błędu sprzętowego

12 else break; //nie ma więcej danych w strumieniu (bo jeden znak zawsze powinno się dać odczytać) std::cout << "Napotkany znak = '" << cznak << "'" << std::endl; //while plik.close(); return true; int main() if( odczytajplik( "cpp0x.txt" ) ) std::cout << "Plik zostal wczytany!" << std::endl; return 0; Podsumowanie Zagadnieniom związanym z wykrywaniem i obsługą błędów poświęcono wbrew pozorom dużo książek oraz publikacji, które stanowią całkiem spory obszar w dziedzinie informatyki. U podstaw tworzenia bezpiecznego kodu leży jednak przede wszystkim świadomość, doświadczenie i umiejętności analityczne programisty. Wiedz, że każdy programista doskonali swoje umiejętności latami poprzez okazjonalne czytanie książek i przede wszystkim poprzez pisanie setek tysięcy linii kodu, podczas realizacji wymyślonych przez siebie (bądź zleconych) projektów. Pamiętaj, że zdobyte przez Ciebie doświadczenie, jak również zaangażowanie w realizowane projekty będą kluczowymi elementami, wpływającymi pozytywnie na jakość kodu, a tym samym na jego odporność na błędy. Zadanie domowe 1. Napisz program, który wczyta z pliku liczby całkowite i wypisze je na ekranie. Wszelkie nieprawidłowe znaki mają zostać pominięte. Program ma wypisać również sumę wszystkich wczytanych liczb. Przykładowa zawartość pliku z danymi: a b9 ac.de ef#@g 5 #3 Oczekiwane standardowe wyjście programu dla przykładowego zestawu danych: Suma liczb wynosi: [trudne zadanie] Napisz program, który dla każdego wiersza w pliku: wczyta liczby i wypisze ich sumę w przypadku, gdy wszystkie liczby uda się wczytać; wypisze komunikat o błędnych danych, jeżeli wystąpi błąd podczas wczytywania liczb (komunikat ma wyświetlać numer wiersza, w którym wystąpił błąd). Przykładowe dane: a # 3 4 Oczekiwane standardowe wyjście programu dla przykładowego zestawu danych: 6 Bledne dane w wierszu nr 2! 5 13

13 Bledne dane w wierszu nr 5! Wykorzystaj poniższą funkcję do wykrywania znaku przejścia do nowej linii: bool czynapotkanoznaknowegowiersza( std::ifstream & plik ) char cznak; for(;; ) //nieskończona pętla plik.clear(); cznak = plik.peek(); //sprawdzamy jaki kolejny znak zostanie zwrócony przez operację odczytu if( plik.fail() plik.bad() ) return false; //wystąpił błąd odczytu danych if(!isspace( cznak ) ) return false; //pobrany znak nie jest białym znakiem plik.get( cznak ); //odczytujemy biały znak z pliku if( plik.fail() plik.bad() ) return false; //wystąpił błąd odczytu danych if( cznak == '\n' ) return true; //for Powyższej funkcji nie wolno modyfikować. Poruszanie się po pliku w trybie do odczytu [lekcja] Rozdział 35. Rozdział opisuje, jak poruszać się po pliku w trybie do odczytu. Wprowadzenie W niniejszym rozdziale dowiesz się w jaki sposób można odczytywać wybrane fragmenty pliku bez konieczności wczytywania jego całej zawartości. Zanim jednak to nastąpi, warto najpierw poświęcić trochę czasu na teorię, a konkretniej na to, jak są przechowywane informacje w komputerze. Logiczna budowa informacji przechowywanych w komputerze Wszystko jest bajtem W świecie informatyki i sprzętu komputerowego wszystko kręci się wokół jednostki bajta. Za jej pomocą wyraża się rozmiar dysków twardych, rozmiar pamięci RAM, architekturę procesorów oraz wiele innych parametrów sprzętu komputerowego. Przyjeło się, że bajt jest najmniejszą logiczną paczką informacji na której pracuje komputer, zatem wszelkie niskopoziomowe narzędzia są przystosowane do pracy z jednym bajtem danych. Odczytując więc jakiekolwiek dane z dysku twardego/pamięci RAM czy też jakiegokolwiek innego nośnika informacji, zawsze będziesz musiał odczytać jeden bajt, nawet jeśli interesuje Ciebie tylko jeden bit do niego należący. Dysk twardy, a jego logiczna struktura Dysk twardy, płytę DVD czy pendrive-a możesz wyobrazić sobie jako jedną wielką jednowymiarową tablicę bajtów. W tej jednowymiarowej tablicy porozrzucane są dane plików, ich nazwy, katalogi i inne bajery, które są niezbędne do poprawnego odczytu informacji zapisanych na nośniku. Sporą część zajmują również bajty w których nie ma zapisanych żadnych użytecznych informacji i w każdej chwili możemy je wykorzystać na to, aby zapisać tam nowe informacje np. nowy plik na dysku. Praca na takiej jednowymiarowej tablicy z danymi byłaby jednak dla nas niewygodna, dlatego też system operacyjny zajmuje się zarządzaniem tej pamięci,

14 dając nam w zamian ładną logiczną strukturę danych w postaci katalogów i plików. System operacyjny dostarcza więc nam cały zbiór narzędzi do wygodnej pracy z danymi zapisanymi na dysku. Plik, a jego logiczna struktura Jak już wiesz, dysk twardy możemy traktować w praktyce jako jednowymiarową tablicę. W niej znajdują się pliki, a dane jednego pliku mogą być (i zazwyczaj są) porozrzucane w różnych miejscach na dysku. Aby dało się jednak wygodnie pracować z plikiem, system operacyjny dostarcza nam narzędzia umożliwiające dostęp do pliku tak, jakby każdy plik był jedną i jednocześnie ciągłą tablicą jednowymiarową. Co więcej, tą jednowymiarową 'tablicę' pliku możemy sobie powiększać do woli, bądź zmniejszać w zależności od tego ile miejsca potrzebujemy na przechowanie interesujących nas informacji. System operacyjny oczywiście odmówi powiększenia pliku, jeżeli nie będzie miał już więcej wolnego miejsca na dysku, no ale nie o to w tym całym wywodzie chodzi :) Pozycja w pliku Jak już wcześniej się dowiedziałeś, każdy plik możemy traktować jak jednowymiarową tablicę z danymi. Dostęp do tej tablicy umożliwiają jak zwykle narzędzia dostarczone przez system operacyjny. Wspomniane narzędzia zostały stworzone tak, aby umożliwiały wygodną pracę z plikiem. Wymyślono więc, że każdy bajt pliku zostanie ponumerowany, a numeracja bajtów w każdym pliku będzie się zaczynała od zera. Pozycja w pliku określa więc numer bajta do którego chcemy się 'dostać' w celu odczytania bądź zapisania nowej informacji. Podsumowanie teorii Z kilku powyższych paragrafów powinieneś dowiedzieć się jak mniej więcej zorganizowane są dane na dysku twardym czy też płycie DVD. Pamiętaj, że przedstawiony powyżej opis jest bardzo ogólny oraz jest bardzo uproszczony w stosunku do rzeczywistości. Ważne jest to, abyś miał jakieś wyobrażenie jak są zorganizowane dane na dysku. Ważne jest również, abyś wiedział czym jest pozycja w pliku, bowiem reszta niniejszego rozdziału będzie koncentrowała się właśnie wokół tego terminu. Ustawianie nowej pozycji odczytu - metoda seekg Do ustawiania tej pozycji w trybie do odczytu służy metoda seekg (g jak get) istream & seekg( streampos pos ); istream & seekg( streamoff off, ios_base::seekdir way ); Pierwsza wersja tej metody ustawia pozycję na. pos znaków od początku pliku, a druga przesuwa pozycję w pliku o off znaków względem punktu określonego przez way way może przyjąć jedną z wartości przedstawionych w tabeli: Wartość ios::be g ios::cu r ios::en d Punkt Początek pliku Aktualna pozycja w pliku Koniec pliku Poniższe zapisy są sobie równoważne:

15 plik.seekg( 16 ); plik.seekg( 16, ios::beg ); Pobieranie aktualnej pozycji odczytu - metoda tellg Aktualną pozycję w pliku do odczytu zwraca metoda tellg. streampos tellg(); Poniższe wywołania robią to samo: plik.seekg( 8, ios::cur ); plik.seekg( plik.tellg() + 8 ); Przykład #include <iostream> #include <fstream> using namespace std; int main() int n; ifstream plik( "dane.txt" ); if(!plik.is_open() ) return 1; plik.seekg( 4 ); plik >> n; cout << "Liczba: " << n << endl; cout << "Wczytano " << plik.tellg() - 4 << "znakow" << endl; // ustawiane przez cout.setf(ios::flaga, floatfield): // scientific - notacja naukowa dla zmiennoprzecinkowych // fixed - notacja zwykła dla zmiennoprzecinkowych // 0 - automatyczny wybór (domylna) // ustawiane przez cout.setf(ios::flaga, adjustfield): // left - wyrównanie do lewej // right - wyrównanie do prawej // internal - wyrównanie do srodka // obsługa plików // oprócz predefiniowanych strumieni możemy tworzyć i kożystac z strumieni zwiazanych z plikami ofstream plik_w; // tworzymy strumień (typu out) zwišzany z plikiem... ifstream plik_r; // tworzymy strumień (typu in) zwišzany z plikiem... plik_w.open("/tmp/plik_w", ios::out ios::ate); // otwieramy plik w trybie dopisywania z możliwocia zmiany dotychczasowej zawartoci

16 plik_r.open("/tmp/plik_r"); // otwieramy plik do czytania // tryby możemy budować z następujšcych opcji: // ios::in - odczyt (domylna dla ifstream) // ios::out - zapis (domylna dla ofstream) // ios::ate - ustawie pozycji na koniec pliku // ios::app - dopisywanie // ios::trunc - nadpisuje plik // ios::noreplace - nie nadpisuje pliku // ios::nocreate - wymaga aby plik istniał cout << "Aktualna pozycja w pliku OUT: " << plik_w.tellp() << endl; cout << "Aktualna pozycja w pliku IN: " << plik_r.tellg() << endl; // pisanie i czytanie dokładnie jak dla cin cout... plik_w << "Hello World!!!"; // możemy tez przemieszczać się w pliku - do okrelonej pozycji // plik_w.seekp( pozycja ); // plik_r.seekg( pozycja ); // lub o okrelonš odległoć (także ujemnš) od pozycji // plik_w.seekp( przesuniecie, tryb ); // plik_r.seekg( przesuniecie, tryb ); // tryb może mieć postaci: // ios::beg - od poczštku // ios::cur - od bieżšcej pozycji // ios::end - od końca // nma koniec zamykamy pliki plik_w.close(); plik_r.close();