C++: Problem mit <fstream> und structs

[patermatrix]

Hallo zusammen!

Ich versuche gerade, 1024 der folgenden Structs in ein File zu schreiben und anschliessend wieder auszulesen.

struct Data{
int id;
short x;
short y;
unsigned char transformation;
float brightness;
};

Der Schreibvorgang sieht folgendermassen aus (die structs befinden sich in einem Array):

ofstream ofs;
ofs.open(outfile);
for(int i=0; i<numOfStructs; i++){
ofs.write(reinterpret_cast<char*>(&array[i]), sizeof(Data));
}
ofs.close();
Anschliessend will ich die Daten an anderer Stelle auslesen und in einen std::vector speichern:

vector<Data> vec;
ifstream ifs;
ifs.open(outfile);
for(int i=0; i<numOfStructs; i++){
Data data;
ifs.read(reinterpret_cast<char*>(&data), sizeof(Data));
vec.push_back(data);
cout << "step " << i << ": reading block nr " << data.id << endl;
}
Die structs tragen alle eindeutige IDs, so dass ich sie problemlos wieder identifizieren kann. Sie werden auch alle schön geschrieben (File ist ~17KB gross). Das Problem entsteht beim Auslesen, wo ich dann nur folgendes zu sehen bekomme:

step 0: reading block nr 0
step 1: reading block nr 1
step 2: reading block nr 2
step 3: reading block nr 3
.
.
.
step 25: reading block nr 25 <- bis hierhin ist alles OK
step 26: reading block nr 25
step 27: reading block nr 25
.
.
.
step 1022: reading block nr 25
step 1023: reading block nr 25
Wie man sieht, wird nach Block 25 (also nach dem 26. struct) nur noch dieses eine struct ausgelesen.

Woran liegt das? Kann mit jemand helfen?

Bzw. Falls jemand eine elegantere Lösung kennt, structs in ein File zu speichern und wieder auszulesen, dann nur her damit!

€: Falls es irgendwie von Belang sein sollte, ich benutze eclipse mit MinGW.

€2: PROBLEM GELÖST!
Musste das File natürlich als binary öffnen (ofs/ifs.open(outfile, ios::binary)) und es funktioniert :uhammer:

[Gast]

Ich habe eine Frage, die auch hier reinpasst:

Sollte man das, was der Threadersteller machen will, wirklich so implementieren? Wie sieht das heutzutage aus, wenn man z.B. 32bit und 64bit Architekturen unterstützen möchte. Auf einem 64bit System sind viele Datentypen 8 Byte groß, die auf 32bit Systemen nur 4 Byte groß sind, daraus folgt doch, dass ein Einlesen einer Datei, die auf einem 32bit System gespeichert wurde, auf einem 64bit System sehr gefährlich werden könnte. Irre ich mich oder kümmern sich die Compiler automatisch darum, was ich mir jedoch nicht vorstellen kann.

Was gäbe es für alternativen, falls nötig? Serialisierung, sodass zusätzlich zu den Daten immer noch die Anzahl der Bytes, die für die Daten gebraucht werden, mitgespeichert werden?

[maximAL]

Sollte man das, was der Threadersteller machen will, wirklich so implementieren?
Bloß nicht.
Was gäbe es für alternativen, falls nötig? Serialisierung, sodass zusätzlich zu den Daten immer noch die Anzahl der Bytes, die für die Daten gebraucht werden, mitgespeichert werden?
Z.B., dafür gibts auch genügend Bibliotheken.