Operacje we/wy na plikach

Stronę tą wyświetlono już: 1255 razy

Zapis/odczyt danych tekstowych

W przypadku zapisu danych składających się często z rekordów o zmiennej długości wygodnie jest wczytywać i zapisywać dane jako tekst, gdzie kolejne elementy danego rekordu są oddzielone umownym znakiem. Takim umownym znakiem może być np. tabulator, średnik i w zasadzie każdy znak, który nie będzie kolidował z formatem zapisywanych danych. W celu skorzystania z klasy odpowiedzialnej za otwieranie i zapis danych w pliku konieczne jest załączenie pliku nagłówkowego fstream, w którym to znajduje się deklaracja klasy o tej samej nazwie, czyli fstream, która to zostanie wykorzystana do zapisu i odczytu danych w pliku tekstowym.

Listing 1
  1. #include <iostream>
  2. #include <fstream>
  3. #include <string.h>
  5. using namespace std;
  7. int main(){
  9. fstream file("file.txt", // ścieżka do otwieranego pliku (w tym przypadku względna)
  10. std::ios_base::out // tryb otwarcia do zapisu
  11. ); // utworznie obiektu typu fstream
  13. if(file.is_open()){ // metoda is_open() sprawdza, czy plik rzeczywiście został otwarty (równie dobrze można użyć metody .good())
  14. for(int i = 0; i < 10; i++){ // od 0 do 9
  15. file << "Tekst "<<i + 1<<endl; // zapis tekstu z znakiem nowej linii na końcu
  16. }
  17. file.close(); // zamykanie pliku
  18. }
  20. file.open("file.txt",std::ios_base::in); // otwarcie tego samego pliku w trybie do odczytu
  22. if(file.is_open()){ // jeżeli otwarte
  23. char buffor[255]; // bufor danych
  24. while(!file.eof()){ // dopuki nie osiągnięto końca pliku
  25. file.getline(buffor, sizeof(buffor) / sizeof(char)); // wczytywanie linii tekstu z pliku (do znaku końca linii)
  26. cout<<buffor<<endl<<endl; // wyświetlanie tekstu
  27. }
  28. file.close(); // zamykaj plik
  29. }
  31. file.open("file.txt",std::ios_base::in); // otwarcie tego samego pliku w trybie do odczytu
  33. if(file.is_open()){ // jeżeli otwarte
  34. string str; // bufor danych
  35. while(!file.eof()){ // dopuki nie osiągnięto końca pliku
  36. getline(file, str); // wczytywanie linii tesktu z pliku (do znaku końca linii) do zmiennej typu string
  37. cout<<str<<endl<<endl; // wyświetlanie tekstu
  38. }
  39. file.close(); // zamykaj plik
  40. }
  42. cout<<"Wcisnij enter, aby zamknac program...";
  43. cin.get();
  45. return 0;
  46. }

Jak wynika z powyższego kodu, już przy tworzeniu obiektu klasy fstream można otworzyć plik, podając konstruktorowi tejże klasy: względną (np. "file.txt") lub bezwzględną ścieżkę dostępu do pliku (np. "C:\file.txt"). Kolejny argument określa tryb dostępu do pliku, który może być kombinacją dwóch ustawień: std::ios::in - do odczytu; std::ios::out - do zapisu. Aby otworzyć plik do odczytu i do zapisu trzeba podać argument: std::ios::in|std::iso::out. Istnieje też możliwość otworzenia pliku za pomocą wewnętrznej metody open, która przyjmuje te same argumenty. Poniżej zamieszczam opis możliwych do użycia trybów odczytu pliku:

std::ios_base::appotwieranie z dopisywaniem danych do końca pliku;
std::ios_base::ateustawia wskaźnik pliku na jego koniec;
std::ios_base::binarywczytywanie danych binarnych;
std::ios_base::intryb do odczytu danych;
std::ios_base::outtryb zapisu danych do pliku;
std::ios_base::trunczrzuca zawartość pliku, która jest tracona w chwili jego otwierania.

Po otworzeniu pliku trzeba się upewnić, czy aby na pewno ten został otworzony. Do tego celu można posłużyć się jedną z dwóch dostępnych metod: is_open() lub good(), obie te metody zwracają true, gdy otwarcie pliku się powiodło, zaś false w przeciwnym przypadku. Równie ważna jest metoda eof(), która zwraca true, gdy podczas odczytu osiągnięto koniec pliku.

W powyższym przykładzie dwukrotnie otworzyłem ten sam plik. W pierwszym jednak przypadku użyłem metody wewnętrznej getline(buffer, bufferSize) gdzie buffer jest typu const char*, a bufferSize jest typu unsigned int; natomiast w drugim funkcji std::getline(file, str) gdzie z kolei pierwszy argument jest typu fstream, drugi zaś typu string.

Czas zrobić nieco ciekawszy przykład, na bazie programu, który wykonałem na stronie Programowanie → Podstawy C++ → Metody wirtualne, czysto wirtualne oraz klasy abstrakcyjne, nie będę przepisywał całego projektu, powiem tylko co gdzie należy dodać. Do definicji klasy abstrakcyjnej iObject należy dodać taką oto czysto wirtualną metodę:

Listing 2
  1. virtual void WriteToFile(std::fstream &f) const =0;// metoda czysto wirtualna związana z obsługą zapisu danych do pliku

Do definicji klasy point2d metodę:

Listing 3
  1. inline virtual void WriteToFile(std::fstream &f) const {f <<"Point2d: x="<<x<<"; y="<<y<<";"<<std::endl;}; // obsługa zapisu do pliku

Do definicji klasy point3d metodę:

Listing 4
  1. inline virtual void WriteToFile(std::fstream &f) const {f <<"Point3d: x="<<x<<"; y="<<y<<"; z="<<z<<";"<<std::endl;}; // obsługa zapisu do pliku

Do definicji klasy line metodę:

Listing 5
  1. inline virtual void WriteToFile(std::fstream &f) const {f <<"Line: x1="<<firstPoint.GetX()<<"; y2="<<firstPoint.GetY()<<"; x2="<<secondPoint.GetX()<<"; y2="<<secondPoint.GetY()<<";"<<std::endl;}; // obsługa zapisu do pliku

Do definicji klasy circle metodę:

Listing 6
  1. inline virtual void WriteToFile(std::fstream &f) const {f <<"Circle: xc="<<x<<"; yc="<<y<<"; ray="<<ray<<";"<<std::endl;}; // obsługa zapisu do pliku

De definicji klasy ellipse metodę:

Listing 7
  1. inline virtual void WriteToFile(std::fstream &f) const {f <<"Ellipse: xc="<<x<<"; yc="<<y<<"; r1="<<r1<<"; r2="<<r2<<";"<<std::endl;}; // obsługa zapisu do pliku

Na koniec kilka funkcji dodatkowych:

Listing 8
  1. void ParseString(std::string str_to_parse, std::vector<std::string> &tString,std::string parse_signs){
  2. if(tString.size()){
  3. tString.clear();
  4. }
  6. std::string::size_type sizeBegin = 0;
  7. std::string::size_type sizeEnd = str_to_parse.find_first_of(parse_signs, sizeBegin);
  9. while(sizeEnd != std::string::npos){
  10. if(sizeEnd != sizeBegin){
  11. tString.push_back(
  12. str_to_parse.substr(sizeBegin, sizeEnd - sizeBegin)
  13. );
  14. }
  16. tString.push_back(
  17. str_to_parse.substr(sizeEnd,1)
  18. );
  19. sizeBegin = sizeEnd + 1;
  20. sizeEnd = str_to_parse.find_first_of(parse_signs, sizeBegin);
  21. };
  22. if(sizeBegin < str_to_parse.size()){
  23. tString.push_back(
  24. str_to_parse.substr(sizeBegin)
  25. );
  26. }
  27. }
  29. void SaveToFile(std::vector<iObject*> &tObject){ // funkcja zapisująca dane o utworzonych obiektach do pliku tekstowego
  30. std::fstream file("SaveFile.txt",std::ios_base::out); // otwieranie pliku do zapisu
  32. if(file.is_open()){ // czy otwarty
  33. for(std::vector<iObject*>::iterator i = tObject.begin(); i < tObject.end(); i++){ // iterowanie po interfejsach obiektów zawartych w kontenerze
  34. (*i)->WriteToFile(file); // zapis
  35. }
  36. }else{
  37. std::cout<<"Wzielo sie i nie zapisalo"<<std::endl<<std::endl;
  38. }
  39. }
  41. void ReadFromFile(std::vector<iObject*> &tObject){ // czytanie danych z pliku tekstowego
  42. std::fstream file("SaveFile.txt",std::ios_base::in); // otwieranie pliku
  43. if(file.is_open()){ // sprawdzanie, czy się otworzył
  44. while(!file.eof()){ // czy koniec pliku został osiągnięty, jak nie to
  45. std::string temp; // pomocnicza do wczytywania zmienna
  46. std::getline(file, temp); // wczytuję
  47. std::vector<std::string> tStr; // tablica do parsowania tekstu z zmiennej pomocniczej temp
  49. ParseString(temp, tStr, " ;="); // parsuję tekst względem spacjji, średnika i znaku równości
  51. if(tStr.size()){ // jak tStr.size() nie jest równe zero to
  52. if(tStr[0].compare("Point2d:") == 0){ // jak pierwszy element zawiera tekst "Point2d:" to
  53. if(tStr.size() == 11){ // jak liczba elementów w tablicy sparsowanego tekstu się zgadza to
  54. std::cout<<"Wczytano Point2d "<<tStr.size()<<std::endl; // info, że tak, syćko jest w pożądku
  55. tObject.push_back(new point2d(atol(tStr[4].c_str()), atol(tStr[9].c_str()))); // i dodaję do tablicy interfejsów nowy obiekt
  56. }else{ // a jak nie, to znaczy się, że ktoś spartolił formatowanie i się nie wczyta
  57. std::cout<<"Cos nie tak w zapisie \""<<temp<<std::endl<<std::endl;
  58. }
  59. }else if(tStr[0].compare("Point3d:") == 0){ // to samo tylko dla "Point3d:"
  60. if(tStr.size() == 16){
  61. std::cout<<"Wczytano Point3d "<<tStr.size()<<std::endl;
  62. tObject.push_back(new point3d(atol(tStr[2].c_str()), atol(tStr[4].c_str()), atol(tStr[14].c_str())));
  63. }else{
  64. std::cout<<"Cos nie tak w zapisie \""<<temp<<std::endl<<std::endl;
  65. }
  66. }else if(tStr[0].compare("Line:") == 0){ // to samo tylko dla "Line:"
  67. if(tStr.size() == 21){
  68. std::cout<<"Wczytano Line "<<tStr.size()<<std::endl;
  69. int x1 = 0, y1 = 0, x2 = 0, y2 = 0;
  70. sscanf(temp.c_str(),"Line: x1=%i; y2=%i; x2=%i; y2=%i;",&x1, &y1, &x2, &y2);
  71. tObject.push_back(new line(x1, y1, x2, y2));
  72. }else{
  73. std::cout<<"Cos nie tak w zapisie \""<<temp<<std::endl<<std::endl;
  74. }
  75. }else if(tStr[0].compare("Circle:") == 0){ // to samo tylko dla "Circle:"
  76. if(tStr.size() == 16){
  77. std::cout<<"Wczytano Circle "<<tStr.size()<<std::endl;
  78. int xc = 0, yc = 0, ray = 0;
  79. sscanf(temp.c_str(),"Circle: xc=%i; yc=%i; ray=%i;",&xc, &yc, &ray);
  80. tObject.push_back(new circle(xc, yc, ray));
  81. }else{
  82. std::cout<<"Cos nie tak w zapisie \""<<temp<<std::endl<<std::endl;
  83. }
  84. }else if(tStr[0].compare("Ellipse:") == 0){ // to samo tylko dla "Ellipse:"
  85. if(tStr.size() == 21){
  86. std::cout<<"Wczytano Ellipse "<<tStr.size()<<std::endl;
  87. int xc = 0, yc = 0, r1 = 0, r2 = 0;
  88. sscanf(temp.c_str(),"Ellipse: xc=%i; yc=%i; r1=%i; r2=%i",&xc, &yc, &r1, &r2);
  89. tObject.push_back(new ellipse(xc, yc, r1, r2));
  90. }else{
  91. std::cout<<"Cos nie tak w zapisie \""<<temp<<std::endl<<std::endl;
  92. }
  93. }
  94. }
  95. }
  96. }else{
  97. std::cout<<"Wzielo sie i nie wczytalo"<<std::endl<<std::endl;
  98. }
  99. }

Oraz zmienione nieco instrukcje wewnątrz funkcji głównej programu:

Listing 9
  1. int main(){
  2. setlocale(LC_CTYPE,"Polish"); // to po to, żeby mieć polskie znaki
  4. std::vector<iObject*> tObject;
  6. ReadFromFile(tObject); // wczytywanie obiektów na podstawie danych zapisanych w pliku tekstowym
  8. WhatYouWantToDo(tObject);
  10. SaveToFile(tObject); // zapisywanie obiektów w pliku tekstowym
  12. DeleteAllObject(tObject,false);
  14. return 0;
  15. }

Zapis/odczyt danych binarnych

Gdy istnieje konieczność zapisania dużej liczby danych stosuje się nieco inny sposób wczytywania. Po pierwsze potrzebna będzie struktura, która będzie nagłówkiem tworzonego pliku. W nagłówku powinny zostać zawarte informacje dotyczące rozmiaru wczytywanych danych. Oto prościutki przykład programu, który zapisuje dane do pliku i wczytuje dane z pliku:

Listing 10
  1. #include <iostream>
  2. #include <fstream>
  3. #include <string.h>
  5. using namespace std;
  7. struct headerfile{ // a to będzie struktura nagłówkowa
  8. unsigned int sizedata; // rozmiar danych zawartych w pliku zaraz za nagłówkiem
  9. char text[21]; // jakiś tam dodatkowy tekst w nagłówku
  10. char author_name[21]; // autor pliku
  11. };
  13. int main(){
  14. fstream file("file.txt",std::ios_base::out|std::ios::binary); // otwieranie do odczytu
  16. if(file.is_open()){ // jak otwarty
  17. cout<<"otworzylem"<<endl;
  18. string data = "dane do zapisu w pliku binarnym";
  19. headerfile *hf = new headerfile; // deklaruję pamięć nagłówka
  20. hf->sizedata = data.size() + 1; // zapisuję informację o rozmiarze danych
  21. cout<<data.size() + 1<<endl<<endl;
  22. strcpy(hf->text, "Jakis tekst"); // wczytuje tekst do pola nagłówka text
  23. strcpy(hf->author_name, "Programista"); // to samo dla pola autor_name
  24. file.write((char*)hf, sizeof(headerfile)); // tutaj zapisuję nagłówek w pliku
  25. file.write(data.c_str(), data.size()); // tutaj zapisuję dane dodatkowe w pliku
  26. delete hf; // zwalniam przydzieloną pamięć
  27. hf = NULL;
  28. file.close(); // zamykanie pliku
  29. }
  31. file.open("file.txt",std::ios_base::in|std::ios::binary); // otwieranie do odczytu
  33. if(file.is_open()){ // jak otwarty
  34. cout<<"otworzylem"<<endl;
  35. char* bf = new char[sizeof(headerfile)]; // przygotowuję bufor danych dla nagłówka
  36. file.read(bf, sizeof(headerfile)); // czytam nagłówek
  37. headerfile *hf = (headerfile*)bf; // uzyskuję dane nagłówka
  38. char* data = NULL; // tutaj będę przechwytywał dane dodatkowe z pliku
  39. string datastr; // a tu je zapiszę jako string
  40. if(hf->sizedata){ // jeżeli sizedata nie równe zero to
  41. data = new char[hf->sizedata]; // rezerwowanie pamięci potrzebnej do pozyskania danych
  42. file.read(data, hf->sizedata); // wczytanie danych
  43. data[hf->sizedata - 1] = 0; // na końcu zero powinno być
  44. datastr = data; // przepisanie danych do stringa
  45. delete data; // zwolnienie pamięci
  46. }
  47. cout<<hf->sizedata<<" "<<hf->text<<" "<<hf->author_name<<" "<<datastr<<endl<<endl; // wypisanie na ekranie wczytanych danych
  48. delete bf; // zwalnianie pamięci bufora
  49. hf = NULL; // zerowanie wskaźnika nagłówka
  50. bf = NULL; // zerowanie wskaźnika bufora
  51. file.close(); // zamykanie pliku
  52. }
  54. cout<<"Wcisnij enter, aby zaknac program...";
  55. cin.get();
  57. return 0;
  58. }
Dodatkowe informacje:
  1. cplusplus.com - spis wszystkich metod i operatorów fstream
  2. cplusplus.com - opis metody open wraz z opcjami otwierania

Tematy powiązane

Komentarze