std::string binär speichern (sorry... ;-))

Zuerstmal sorry dass schon wieder ne Frage zu FH kommt, aber irgendwie bekomme ich es nicht hin, einen String binär zu speichern und wieder auszulesen.
Folgendes sollte doch eigentlich klappen:

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

void save(string save_what)
{
    fstream file("my_file.dat", ios_base::out | ios::binary);
    //Fehlerüberprüfungen...
    file.write((char*)&save_what, sizeof(save_what));
    file.close();
}

void load(string *load_into)
{
    fstream file("my_file.dat", ios_base::in| ios::binary);
    //Fehlerüberprüfungen...
    file.read((char*)load_into, sizeof(load_into));
    file.close();
}

int main()
{
    string foo = "Foo";
    save(foo);
    string foo2 = "";
    load(&foo2);
    cout << foo << " wird zu: " << foo2;
    return 0;
}

Sowas kompiliert anstandslos, aber irgendwie kommt nur schrott in foo2 an. Außerdem kann man den String im File nicht lesen (sollte man doch sowohl bei binary als auch bei ascii?)
Wäre echt nett wenn ihr mir diese blöde Frage beantworten könntet.

Was mir grad noch einfällt:
Muss ich vielleicht beim sizeof in read den pointer dereferenzieren? also:
file.read((char*)load_into, sizeof(*load_into));

std::string::c_str()

das könnte ich aber höchstens bei file.read() nehmen, da es zu const char* konvertiert. Meintest du das?

Hallo,

du kannst auch fuer const char* den op-<< nutzen. BTW: Du kannst eine Instanz
nicht einfach in eine Datei speichern und wieder laden.

mfg
vR@work

wozu willst du sowas überhaupt machen ?
ein String ist imho ungeeignet für binäre daten, da dies nicht seine aufgabe ist.
Evtl. wäre ein vector<char> hier angebrachter.

Zu dem kannst du NICHT einfach per read daten in einen String schreiben, wenn
über haupt müssest du die Daten auslesen (z.b. in ein char[] und sie dann
in den einfügen (=,append). Bei write müsste es aber eigentlich mit c_str klappen.

Ich will den String in eine binäre Datei schreiben, da ich da auch alle möglichen anderen Sachen reinschreibe, und ich das Ganze nicht trennen will.

Zu dem kannst du NICHT einfach per read daten in einen String schreiben, wenn
über haupt müssest du die Daten auslesen (z.b. in ein char[] und sie dann
in den einfügen (=,append).

Und woher soll ich dann wissen wieviele bytes ich in den char[] auslesen soll, d.h. wann der String zu Ende ist? Mit getline und einem interruptor?

also z.B.

char delim[2] = ",";
file.write((ein_string.c_str(), sizeof(ein_string));
file.writ(&delim, sizeof(delim));

//closen, im readmode öffnen...

char dummy[];
file.getline(&dummy, 256, ",");

Gruß

ich machs in der Regel so, das ich erst die Länge des STring speichere,
und dann den string reinschreibe, beim auslesen dann das selbe spiel...

Ok, dann macht man das also so. Hab mich immer gefragt ob es nicht auch einfacher geht, aber nunja... Ich habe aber schon gesehen, dass man ganze Klassen und structs einfach mit write() und read() speichern und lesen kann. Das hat auch immer funktioniert, von strings mal abgesehen, deshalb hab ich gefragt. Funktioniert es eigentlich, wenn man char arrays in structs direkt mitspeichert?

Also machst du das so oder:

string foo "looool, ich bin ein String...";
int i = 10;
float f = 20,4;

fstream file("test.dat", ios_base::out | ios::binary);
//Checks...
file.write((char*)&i, sizeof(i));
file.write((char*)&f, sizeof(f));
file.write((char*)&sizeof(foo), sizeof(sizeof(foo))); //länge speichern
file.writ((char*)&foo, sizeof(foo)); //strig speichern

//lesemode;
fstream file("test.dat", ios_base::in | ios::binary);
int i1; float f1; string foo1;

file.read((char*)&i1, sizeof(i1));
file.read((char*)&f1, siezof(f1));
int len;
file.read((char*)&len, sizeof(len)); //länge lesen
file.read((char*)&foo1, len);

Machst du das ungefähr so?

Oder statt die ganzen numerischen sachen einzulesen einfach:

struct x
{
    int i;
    float f;
};
x test;

file.write((char*)test, sizeof(x));

Hab ich das jetzt richtig verstanden?

Hab jetzt mal folgendes geschrieben. Funktioniert aber irgendwie nicht. Keine Fehlermeldungen oder Abstürze, nur die Ausgabe ist nicht richtig. Wo könnte der Fehler liegen?

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

int main()
{
    string write_me = "That's supposed to be a written binary string...";
    string read_to_me = "";

    ///////////////////////////////////////////////////////////////////////
    //WRITE
    ///////////////////////////////////////////////////////////////////////
    //store size of string 
    size_t size_of = sizeof(write_me);
    cout << "size_t written: " << size_of << "\n";    

    ofstream writefile("file.bin", ios_base::out | ios::binary);   
    //write size of string
    writefile.write((char*)&size_of, sizeof(size_t));
    //write string
    writefile.write((char*)&write_me, sizeof(write_me));

    writefile.close();

    ///////////////////////////////////////////////////////////////////////
    //READ
    ///////////////////////////////////////////////////////////////////////    
    ifstream readfile("file.bin", ios_base::in | ios::binary); 

    //get size of string
    size_t size_to_read;
    readfile.read((char*)&size_to_read, sizeof(size_t));
    cout << "size_t read: " << size_to_read << "\n"; 
    //get string with size_of1
    char dummy[1000];
    readfile.read((char*)&dummy, size_to_read);
    read_to_me.append(dummy);

    readfile.close();

    ///////////////////////////////////////////////////////////////////////
    //DISPLAY
    ///////////////////////////////////////////////////////////////////////
    cout << "Written: " << write_me << "\n";
    cout << "Read: " << read_to_me << "\n";    

    system("PAUSE");
    return EXIT_SUCCESS;
}

the_alien

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

int main()
{
    string write_me = "That's supposed to be a written binary string...";
    string read_to_me = "";

    ///////////////////////////////////////////////////////////////////////
    //WRITE
    ///////////////////////////////////////////////////////////////////////
    //store size of string
    size_t size_of = write_me.length();
    cout << "size_t written: " << size_of << "\n";    

    ofstream writefile("file.bin", ios_base::out | ios::binary);  
    //write size of string
    writefile.write((char*)&size_of, sizeof(size_t));
    //write string
    writefile.write(write_me.c_str(), write_me.length());

    writefile.close();

    ///////////////////////////////////////////////////////////////////////
    //READ
    ///////////////////////////////////////////////////////////////////////    
    ifstream readfile("file.bin", ios_base::in | ios::binary);

    //get size of string
    size_t size_to_read;
    readfile.read((char*)&size_to_read, sizeof(size_t));
    cout << "size_t read: " << size_to_read << "\n";
    //get string with size_of1
    char dummy[1000];
    readfile.read((char*)&dummy, size_to_read);
    read_to_me = dummy;
    readfile.close();

    ///////////////////////////////////////////////////////////////////////
    //DISPLAY
    ///////////////////////////////////////////////////////////////////////
    cout << "Written: " << write_me << "\n";
    cout << "Read: " << read_to_me << "\n";    

    system("PAUSE");
    return EXIT_SUCCESS;
}

Hängt zwar noch etwas mist hinten an dem String, aber darum wollte ich mich jetzt nichtmehr kümmern

virtuell Realisticer

du kannst auch fuer const char* den op-<< nutzen. BTW: Du kannst eine Instanz
nicht einfach in eine Datei speichern und wieder laden.

Warum schreib ich ueberhaupt?

mfg
v R

phlox81

Dann leiste ich mal etwas 'Entwicklungshilfe'

string ReadString(istream& i)
{
	int n =0;
	i >> n;
	if(n > 1)
	{
		char * c = new char[n];
		i.read(c,n);
		string s =c;
		delete[] c;
		return s;
	}
	return "";
}

void WriteString(ostream & o, const string& s)
{
	o << (int)s.size()+1;
	if(s.size()>0)
		o << s << '\0';
	else
		o << ' ';
}

Devil

*push*

BTW: Du kannst eine Instanz
nicht einfach in eine Datei speichern und wieder laden

Sorry aber ich weiß nicht wie du das meinst... Ein String ist doch einfach ein ganz normaler Dateityp (naja, kein standard-dateityp sondern aus einer library aber immerhin...) Was meinst du mit Instanz? Ok, jeder String ist eine Instanz der Stringklasse. Kann ich die deshalb nicht direkt speichern, weil die Klasse noch allen möglichen anderen Schrott enthält?
@devil81:
Dankeschön!

MFK

cppler schrieb:

Kann ich die deshalb nicht direkt speichern, weil die Klasse noch allen möglichen anderen Schrott enthält?

Du kannst die deshalb nicht speichern, weil sie dynamisch angeforderten Speicher benutzt. "Schrott" würde ich das nicht nennen.

Ach so, ist ja eigentlich auch logisch, da ein String ja im Gegensatz zu einem char arry keine feste Größe hat...