Zapis i odczyt tablicy obiektów do pliku

Witam. Mam dynamiczną tablicę <vector>. W niej są przechowywane obiekty głównej klasy. Główna klasa dziedziczy po pomniejszych klasach(np. klasa o nazwie Imie przekazuje klasie głównej(przez dziedziczenie) tablicę imion). Chciałbym zapisać obiekty klasy głównej(przechowywane w tablicy) do pliku oraz móc wczytać zapisane w pliku obiekty z powrotem do tablicy. Szukałem sporo na ten temat i próbowałem wielu rozwiązań. Zapis pliku zrealizowałem w ten sposób:```

                        //Flota - klasa główna
                        vector <Flota> baza;//w tablicy mam np. 5 obiektów
                        fstream zapisDoPliku;
			
			zapisDoPliku.open("plikk.dat", ios::out | ios::binary);

			for (int i = 0; i < baza.size(); ++i)
			{
				zapisDoPliku.write((char*)&baza[i], sizeof(baza[i]));
			}
			zapisDoPliku.close();
			

Niestety nie mogę odnaleźć sposobu na odczyt danych do tablicy(przez co sprawdzę też czy dobrze zapisałem dane :) ).

Przy zapisywaniu po każdej zmiennej daj spację żeby oddzielić dane. Przy odczycie czytany plik zamień na stringstream i wyjmuj dane po kolei metodami stoi (string to int) / stod (string to double) / stof (string to float), ale żeby korzystać z tych metod musisz korzystać z cpp11.

EDIT: Słaby jestem z cpp, ale przy takim zapisie danych chyba zapisujesz tylko adresy pamięci. Ja pomyślałbym o jakimś data serializer, który z obiektu danego typu wyjmuje wszystkie zmienne i zapisuje je.

Poczytaj o serializacji danych w C++.

Na jednym z wątków na forum ktoś podał taką stronę http://www.functionx.com/cpp/articles/serialization.htm. Użyłem poleceń na niej zawartych i na ten moment mogę już zapisywać i odczytywać tablicę obiektów do pliku :) . Sprawdzałem jednak na bardzo ubogiej klasie (bo mającej wyłącznie 1 zmienną). Później dam znać czy to rozwiązanie też działa dla klasy wyglądającej jak ta, którą opisałem w pierwszym poście.

Problem nie pokazałeś czym jest Flota. Jeśli ta klasa zawiera wskaźniki lub inne klasy ich używające, to to nie ma szansy zadziałać.

A ta strona IMO reprezentuje nikłą wartość (wystarczy zmiana ustawień kompilatora i już nie da się odczytać danych zapisanych poprzednim buildem).

#include<iostream>
#include <vector> 
#include <string>
#include <fstream>

using namespace std;


class klasaA
{
public:
	vector<string>tab;
	virtual void zapisz()
	{
		string imie;
		
		cout << "Podaj imie:";
		cin >> imie;
		tab.push_back(imie);
		cout << "Podaj imie:";
		cin >> imie;
		tab.push_back(imie);
	}
	virtual void wyswietl()
	{
		for each (string imie in tab)
		{
			cout << imie << endl;
		}
	}
};
class Rodzina : public klasaA
{
};

int main()
{
	vector <Rodzina> baza;

	for (int i = 0; i < 2; i++)
	{
		baza.push_back(Rodzina());
	}
	cout << "1.zapisz do pliku" << endl;
	cout << "2.odczyt z pliku" << endl;
	cout << "3.uruchom funkcje imion" << endl;
	cout << "4.wyswitl obiekt" << endl;
	cout << "Wybierz opcję: ";

	int opcja;
	do
	{
		cin >> opcja;
		switch (opcja)
		{

		case 0: { cout << "Koniec" << endl; return 0; }
		case 1:
		{
			ofstream ofs("D:\\BazaDanych.bin", ios::binary);

			for each (Rodzina element in baza)
			{
				ofs.write((char *)&element, sizeof(element));
			}
	
			ofs.close();
			cout << "Zapis\n";
			cout << "Wybierz: ";
			break;
		}
		case 2:
		{
			ifstream ifs("D:\\BazaDanych.bin", ios::binary);
		
			for (int i = 0; i < 1; i++)
			{
				Rodzina obiekt2;
				ifs.read((char *)&obiekt2, sizeof(obiekt2));
				baza.push_back(obiekt2);
			}
			
			ifs.close();
			cout << "Odczyt\n";
			cout << "Wybierz: ";
			break;
		}
		case 3:
		{
			baza.at(0).zapisz();
			cout << "============================================" << endl;
			baza.at(1).zapisz();
			cout << "Wybierz: ";
			break;
		}
		case 4:
		{
			for (int i = 0; i < 2; i++)
			{
				baza.at(i).wyswietl();
				cout << "********************************************************"<<endl;
			}
			cout << "Wybierz: ";
			break;
		}

	
		default: {cout << "Wprowadziłeś błędną wartość. Proszę podaj liczbę od 0 do 8: "; break; }
		}
	} while (true);

}

Mój program będzie korzystał z powyższych rozwiązań, czyli w jednej pomniejszej klasie zbieram informacje od użytkownika i zapisuje je do tablicy dynamicznej. W main() tworze obiekt klasy głównej i z niego wywołuje metodę klasy którą dziedziczy po pomniejszej klasie. Mam problem w tym, że nie mogę wczytać teraz tych danych bo wywala mi się program. Nie wiem czy to wina kodu czy samej metody zapisu i odczytu danych z pliku

ifs.read((char *)&obiekt2, sizeof(obiekt2));

To nie zadziała prawidłowo....
Masz 3 wyjścia, albo zapisujesz wszystko w linijkach jako strinngi cos ala plik csv, ale to będzie niewygodne, jeśli będziesz miał jakieś relacje.
dużo lepsze sa formaty opisowe, np tekstowy - xml, albo binarny - stary dobry iff...

Taki zapis jak dales powyżej nie zadziała, choćby dlatego, ze masz tam vector stringów, jak myślisz jaki rozmiar jest klasy w zalezności od aktualnej wielkości wektora?

Tak jak kaczus powiedział, najlepiej byłoby typowo xmlem to rozwiązać.
Możesz też zrobić to w ten sposób, nie jest to eleganckie ale jak na początek w zupełności powinno wystarczyć.
Przydałaby się również obsługa błędów.

private:
    bool read(std::ifstream &file,char *data,size_t size){
        if(!file.eof()){
            file.read(data,size);
            return true;
        }
        return false;
    }
public:
    void my_write(std::ofstream &file){
        size_t size = tab.size();
        file.write(reinterpret_cast<char *>(&size),sizeof(size_t));
        for(std::string x : tab){
            size_t str_size = x.size();
            file.write(reinterpret_cast<char *>(&str_size),sizeof(size_t));
            file.write(x.c_str(),x.size());
        }
    }
    bool my_read(std::ifstream &file){
        bool ret = false;
        size_t size = 0;
        ret = read(file,reinterpret_cast<char *>(&size),sizeof(size_t));
        for(size_t i=0;i<size;++i){
            std::string name;
            int str_size = 0;
            ret = read(file,reinterpret_cast<char *>(&str_size),sizeof(size_t));
            name.resize(str_size);
            ret = read(file,&name[0],str_size);
            tab.push_back(name);
        }
        return ret;
    }

Można to jeszcze bardziej uprościć odnośnie typów i zapisu.
Tutaj masz kolejno my_write, najpierw zapisujesz wielkość wektora, następnie w pętli wielkość stringa i sam string.
Odczytujesz w drugą stronę, czyli wielkość wektora, potem w petli - wielkość stringa i dane aż do pierwszej wczytanej liczby elementów wektora.

Aby te metody działały z Twoim kodem należy wprowadzić kilka zmian (w kodzie masz wiele niezrozumiałych i śmieciowych rzeczy):

int main()
{
    vector <Rodzina> baza;
//bez tych dziwnych linijek
    cout << "1.zapisz do pliku" << endl;

...
//zapis
            ofstream ofs("./BazaDanych.bin", ios::binary);

            for(auto element : baza)
            {
                element.my_write(ofs);
            }
...
//odczyt
            while(true)
            {
                Rodzina obiekt2;
                if(!obiekt2.my_read(ifs))
                    break;
                baza.push_back(obiekt2);
            }
...
//zapis do obiektu
        case 3:
        {
            for(int i = 0;i<2;++i){
                Rodzina obiekt;
                obiekt.zapisz();
                baza.push_back(obiekt);
                cout << "============================================" << endl;
            }
...
// wyswietlanie
        case 4:
        {
            for(auto x : baza)
            {
                x.wyswietl();
                cout << "********************************************************"<<endl;
            }

Zastosowałem powyższy kod i działa. Wielkie dzięki Mały Krecie. Mam jeszcze pytanie. Moja klasa bazowa będzie dziedziczyć jeszcze bo innych klasach pomniejszych(jedna będzie też zawierać tablice vector, inne zmienne string itp). Rozumiem,że musiałbym za każdym razem modyfikować my_write oraz my_read gdy będę dołączał kolejne dziedziczenia do klasy. Jest to dość kłopotliwe. Jest może jakieś prostsze rozwiązanie i bardziej uniwersalne?

Podpowiedź - pomyśl o metodach wirtualnych, jeśli mają byc różne dane, to jednak czytać należałoby troche inaczej, najpierw zanalizować jaka dana jest zapisana i dopiero pozniej tworzyć odpowiednią daną i wczytać informacje...

kaczus napisał(a):

Podpowiedź - pomyśl o metodach wirtualnych, jeśli mają byc różne dane, to jednak czytać należałoby troche inaczej, najpierw zanalizować jaka dana jest zapisana i dopiero pozniej tworzyć odpowiednią daną i wczytać informacje...

Cały czas korzystam z metod wirtualnych w klasach pomniejszych. Właśnie te wirtualne metody dziedziczy klasa główna.

Jeśli zapisujesz do jednego pliku to zrobiłbym to w ten sposób:

1. Ustanowiłbym jedną klasę do obsługi pliku lub medium do zapisu. Ogólnie strumienia. Klasa powinna być bezpieczna wątkowo na poziomie zapisu obiektów, jeśli po takim rozróżnieniu miało by się to odbywać. Dodatkowo klasa powinna być singletonem, czyli mieć tylko jeden obiekt w czasie.

2. Do tego stworzyłbym "szablonową klasę", która zapisuje odpowiednie dane w odpowiedni sposób. Klasa powinna być całkowicie niezależna, aby móc ją później wymienić. Powinna tworzyć "ramkę" dla obiektu i przyjmować dane z klasy opisanej poniżej.

3. Ostania klasa implementowała by sposób zapisu danych prostych i złożonych. Tutaj można wesprzeć się trochę szablonami. Czyli tworzenie lub odczyt danych z typu (taki transaltor pomiędzy mediami). Typy proste to np int,bool, floaty, stringi ... . Coś co można zapisać w prosty sposób. zapis/odczyt vectora byłby realizowany na podstawie typu szablonowego. Czyli określasz typ i odczytujesz dane z pliku iteracyjnie za pomocą metod typów prostych.

I teraz w klasie głównej dodałbym interfejs zapisujący, który nie powinien nigdy się zmieniać. Zmianie powinien podlegać tylko system zapisu w zależności od klasy lub gdy dodasz zmienne do klasy.

I teraz mamy dziedziczenie. Każda klasa powinna zawierać metodę do zapisu/odczytu. Klasa pochodna wywołuje meotody zapisu/odczytu klas bazowych. Ogólnie powinno to być na podstawie łańcucha. Ważne aby metody były wirtualne, czyli gdy wywołasz zapis/odczyt klasy pochodnej to wywoła się ona, a nie metoda z klasy bazowej.

Tak po prawdzie to nigdy nie używaj dziedziczenia, jeśli na prawdę nie musisz, które wiąże Ci na stałe klasy. To jest złe podejście. Lepiej korzystać np z kompozycji. Czyli jak potrzebujesz klasy z dodatkowymi właściwościami to dodaj obiekt do wnętrza klasy jako zmienną i z niej korzystaj. To jest prostrze podejście w testowaniu i późniejszej poprawie lub zmianie klasy.