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

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

  • ?

    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ß

    0
  • ?

    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...

    0
  • ?

    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? 😉

    0
  • ?

    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;
}
    0
  • T
     

    #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 😃

    0
  • V

    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

    0
  • P

    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

    0
  • ?

    *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! 🙂

    0
  • M

    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.

    0
  • ?

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

    0
Anmelden zum Antworten