dynamische Variablen in Datei schreiben

Norman0406

Hi,
ich habe eine Struktur, die einige dynamische Objekte, z.B. einen String
speichert.
Bsp:

struct MyStruct
{
   char* mystring;
};

und dann wird halt später eine Instanz dieser Klasse erstellt und
MyStruct::mystring einen Wert zugewiesen. Ich möchte jetzt diese Struktur
binär in einer Datei speichern und das funktioniert nicht. Denke dass es
nicht klappt, da mystring ja nur den Pointer auf das erste Element speichert
und der Inhalt im Speicher liegt und somit nur der Pointer geschrieben wird
während der Speicher nach Ablauf des Programms gelöscht wird. Somit kann
ich beim Lesen nicht auf den String zugreifen...
Nur - wie kann ich dann am besten anders dynamisch einen String in der
Struktur speichern, den ich dann passend schreiben kann?
Das gleiche Problem hab ich mit "string" und "CString" auch (basieren ja
auf char*)

Caipi

Ich verstehe dein Problem nicht so wirklich. Willst du den Wert von z.B. mystring in eine Datei schreiben und später (beim nächsten Programmstart) wieder auslesen? Das ist doch kein Problem. (Aber ich glaube, das war nicht deine Frage, oder?)

Caipi

Norman0406

doch das war die Frage. Hab halt diese Struktur die ich binär in eine Datei schreibe. Wenn ich die später wieder auslese, enthält mystring nicht den Inhalt den ich reingeschrieben hab sondern nur wirres Zeugs.

Caipi

Meinst du das etwa so:

#include <iostream>
#include <fstream>
using namespace std;

struct myStruct
{
        std::string str;
};

int main(int argc, char* argv[])
{
        if(argc == 2)
        {
                myStruct foo;
                myStruct bar;
                foo.str = "Hallo Welt!";

                ofstream out(argv[1], ios::binary);
                ifstream in(argv[1], ios::binary);
                out << foo.str << endl;
                if(in.is_open())
                        getline(in, bar.str);

                cout << "\n bar.str: " << bar.str << endl;
        }
        return 0;
}

Das Funktioniert doch, oder?

Caipi

evilissimo

#include <fstream>
#include <iostream>

struct MyStruct
{
   char* my_string;
}; 

void read(); void write();

int main()
{
	write(); read(); 
}

void write()
{
  MyStruct bla;
  bla.my_string = new char[20];
  strncpy(bla.my_string , "Hello World!", 20);

  std::cout << my_string << std::endl;

  unsigned string_size = strlen(my_string);

  std::ofstream of("afile.dat",std::ios::binary);

  of.write(reinterpret_cast<char*>(&string_size),sizeof(unsigned));
  of.write(my_string,string_size);
  of.close();

  delete[] my_string;
}

void read()
{
  MyStruct foobar;
  std::ifstream ifs("afile.dat",std::ios::binary);

  unsigned size_of_string = 0;

  ifs.read(reinterpret_cast<char*>(&size_of_string),sizeof(unsigned));

  foobar.my_string = new char[size_of_string+1];

  ifs.read(foobar.my_string, size_of_string);

  std::cout << foobar.my_string << std::endl;
  ifs.close();
  delete[] foobar.my_string;
}

// Edit: Die files sind aber dann nicht portabel. ( Big Endian <=> Little Endian )

Norman0406

danke, das funktioniert. schätze es war simpel, da muss irgendein Fehler
gelegen haben.