Struct mit Vectoren binär speichern und laden

theta

Lies mal die beiden Threads durch:
http://www.c-plusplus.net/forum/viewtopic-var-t-is-257297.html
http://www.c-plusplus.net/forum/viewtopic-var-t-is-252771.html

Simon

Kontrasubjekt

Ein std::vector hält einen pointer auf daten die im heap existieren. Speicherst du eine struktur, die pointer auf daten enthält, wird auch nur gespeichert was in dem Speicherbereich existiert, den die struktur besetzt, und natürlich nicht das auf was die pointer zeigen. Du musst also über die elemente iterieren und sie einzeln abspeichern. std::string hält ebenfalls einen pointer, also musst du auch über die stringelemente iterieren.

Mathiable

Danke für die schnelle Antworten.

Michael E. schrieb:

Stichwort Serialisierung.

http://www.highscore.de/cpp/boost/ -> Kapitel 11

Ich versuche gerade noch aus der Serialisierung schlau zu werden, aber ich scheitere bereits ab dem istallieren der Boost Library. Scheint irrgendwie nicht richtig mit CodeGear zu laufen. Habe es installiert und weiss nun nicht genau was ich tun muss, damit CodeGear die Librarys erkennt. Damit wäre ich aber bereits im Falschen Forum.
Hoffe du kannst mir bald Antworten, ansosnten mache ich es wie Kontrasubjekt gesagt hat eben einzeln.

Michael E.

Auf http://www.boostpro.com/download gibts nen Installer, mit dem die Installation problemlos klappen sollte.

Mathiable

Den habe ich eben installier, ist aber für VS.
Naja, mach ich es eben einzeln...

Vll hilft dir das

template <class T>
void PackVector(ostream* pFile, vector<T>* pData)
{
	if (pFile && pData)	
		for (int i = 0; i < pData->size(); i++)
			pFile->write((char*) pData->at(i), sizeof(T));
}

template <class T>
void SaveVector(ostream& File, const vector<T>& Data)
{
  File.write((char*) &Data[0], sizeof(T)*Data.size());
}

Geht natürlich nur mit eingebauten Typen.

Vll hilft dir das

template <class T>
void PackVector(ostream* pFile, vector<T>* pData)
{
	if (pFile && pData)
	{	
		for (int i = 0; i < pData->size(); i++)
			pFile->write((char*) &pData->at(i), sizeof(T));
	}
}

hmmmm schrieb:

template <class T>
void SaveVector(ostream& File, const vector<T>& Data)
{
  File.write((char*) &Data[0], sizeof(T)*Data.size());
}

Geht natürlich nur mit eingebauten Typen.

Wird da alles abgespeichert oder nur das erste Element? (wegen Data[0])

Roger Wilco

Beliaz schrieb:

Wird da alles abgespeichert oder nur das erste Element? (wegen Data[0])

Alles:

File.write((char*) &Data[0], sizeof(T)*Data.size());

&Data[0] ist der Zeiger auf das erste Element.

Braunstein

Da er vector<string> hat reicht das nicht. Für den string braucht ihr auch noch eine Serialisierungsfunktion.
Macht mal.

padreigh

warum eigentlich

include <stdio.h>
#include <vector> 

struct Dat{
      std::vector <std::string> Name;
      std::vector <std::string> Vorname;
      std::vector <std::string> Adresse;
      std::vector <int> PLZ;
      std::vector <std::string> Ort;
      int Zähler;

} Data;

und nicht

include <stdio.h>
#include <vector>
using namespace std;

struct Dat{
      std::string Name;
      std::string Vorname;
      std::string Adresse;
      int PLZ;
      std::string Ort;
};

typedef DatVec std::vector<Dat>;
DatVec Data;

würde das nicht von der Datenbündelung her wesentlich mehr Sinn machen? Dein Zähler fällt weg, dafür gibts std::vector<Dat>::size(), zwei freie Funktionen die operator<< und >> auf Dat und DatVec für ifstream und ofstream überladen sollten dann doch genügen? Bin unsicher, habe bisher selten mit binärer speicherung gearbeitet ... Vermutlich müsstest du dann wohl sowas wie string-size,char[] wegschreiben und einlesen?

HighLigerBiMBam

padreigh schrieb:

würde das nicht von der Datenbündelung her wesentlich mehr Sinn machen?

Nicht nur würde, ist definitiv sinnvoller.