ich habe ein Problem mit der Ausgabe eines 32Bit-Integers in C++ und komme nicht weiter.

using namespace std;
...
ofstream file;
file.open("out", ios::binary);

char* buffer = new char[4];
uint32_t x = 0;
*buffer = x;
file.write(buffer,4);

file.close();

Der Code compiliert ohne Probleme, aber die 32 Bits der Datei "out" sind nicht alle gleich 0. Ich bin mir sicher, man muss den uint32_t noch casten, aber wie? Habe schon vieles ausprobiert.

Mit

file << x;

funktioniert es auch nicht.
Wie kann man ganze 32-Bit auf einmal schreiben und nicht nur 8-Bit char?

Vielen Dank!
Grüße,
Max

std::ofstream file("out", ios::out | ios::binary);
uint32_t x = 0;
file << x << std::flush;

Edit: Du musst binary soweit ich weiß noch mit ios::out verbinden.

evtl musst du aber auch noch ein flush verwenden.

Warum?

1. fstreams können RAII, benutze dies auch.

Okay, aber ich bin eigentlich kein Freund von OOP, das müsste ich doch dann auch konsequent machen, oder? Oder kann es auch daran liegen, dass mein Code nicht funktioniert?

314159265358979 schrieb:

2. file << x funktioniert, evtl musst du aber auch noch ein flush verwenden.

std::ofstream file("out", ios::out | ios::binary);
uint32_t x = 0;
file << x << std::flush;

Funktioniert leider so auch noch nicht...

Okay, aber ich bin eigentlich kein Freund von OOP,

Warum benutzt du dann C++?

Der Code compiliert ohne Probleme, aber die 32 Bits der Datei "out" sind nicht alle gleich 0.

Du setzt ja auch nur das erste deiner 4 chars auf 0.

std::ofstream file("out", ios::binary);
uint32_t x = 0;
file.write(reinterpret_cast<const char*>(&x), sizeof(x));

std::ofstream file("out", ios::binary);
uint32_t x = 0;
file.write(reinterpret_cast<const char*>(&x), sizeof(x));

Funktioniert so leider auch nicht.
Naja, ich werde es nun anders machen und die chars einzeln schreiben.

Vielen Dank nochmal für eure Antworten!

char* buffer = new char[4];
uint32_t x = 0;
*buffer = x;

Naja, Du sagst:

• buffer ist ein Array aus char . Ein char ist ein Byte groß.
  -Die Zuweisung sagt, fülle den Wert von x in das erste char. x ist 0, also wird das erste char in dem Array auf 0 gesetzt. Die anderen drei bleiben wie sie sind.

uint32_t x = 0;
*reinterpret_cast<uint32_t*>(buffer) = x;

Übrigens noch zur ersten Frage:

file << x;

übersetzt die Zahl in lesbare Zeichen, aus dem Wert 0 wird also das ASCII-Zeichen für '0' (= 0x30).

Mit dem char-Buffer schreibst Du dagegen direkt den Wert 0 als ASCII 0x00.

Was genau soll Deine Anwendung denn so speichern, und wie soll es nachher wieder gelesen werden?

file << static_cast<char>(x>>24) << static_cast<char>(x>>16) << static_cast<char>(x>>8) << static_cast<char>(x)

Das funktioniert auch, aber wenn ich versuche diesen Wert wieder zu lesen:

uint32_t value = 0;
char buffer;

for(int i=3; i>=0; i--)
{
  in >> buffer;  // in ist ifstream
  value |= static_cast<uint32_t>(buffer) << i*8;
}

...dann gibt es bei manchen(!) Zahlen Probleme:

Bsp.: 23478123 wird korrekt wieder ausgelesen, 40703756 aber nicht, da kommt 40703767 raus. Wenn man sich die Hexadezimal-Darstellung von 40703756 ansieht, stellt man fest, dass im Speicher zwar korrekt 026D170C steht, aber 026D1717 ausgelesen wird! Als ob das vorletzte Byte aufs letzte kopiert wird.

Frage: Was ist der "Standard"-weg, beliebige Folgen von uint32_tund uint8_tin eine Datei zu schreiben? Muss man dabei berücksichtigen, dass auf x86 LittleEndian verwendet wird, oder spielt das keine Rolle, wenn man immer genau die selbe Anzahl Bytes liest, die man auch geschrieben hat?

Was genau soll Deine Anwendung denn so speichern, und wie soll es nachher wieder gelesen werden?

Es sollen Integer gespeichert werden bzw. uint32_t und uint8_t. Also keine characters.

Funktioniert so leider auch nicht.

Das ist keine ausreichende Fehlerbeschreibung.

in >> buffer;

halt

buffer = in.get();

Das ist keine ausreichende Fehlerbeschreibung.

Sorry.
Ich mach jetzt:

std::ofstream file("out", ios::binary);
uint32_t x = 0;
file.write(reinterpret_cast<const char*>(&x), sizeof(x))

std::ifstream infile("out", ios::binary);
uint32_t value;
char* buffer = new char[4];
infile.read(buffer,4);
y = static_cast<uint32_t>(*buffer);
std::cout << y << std::endl;

So wird auch 0 ausgegeben und wenn ich z.B. x=123 eingebe, kommt auch 123 als Ausgabe, aber bei x=12345 kommt 57 heraus, bei x=1234 kommt 4294967250 raus. Da 57 = 0x39 und 12345 = 0x3039 gehe ich davon aus, dass die Funktionen mit der Reihenfolge der Bytes für die integer-Darstellung durcheinanderkommen, bzw. Bytes auslassen.

std::ifstream infile("out", ios::binary);
uint32_t value;
char* buffer = new char[4];
infile.read(buffer,4);
y = static_cast<uint32_t>(*buffer);
std::cout << y << std::endl;

Das ist Blödsinn. Du liest 4 Bytes, füllst dann aber y nur aus dem ersten.

std::ifstream infile("out", ios::binary);
uint32_t value;
infile.read(reinterpret_cast<char*>(&value), sizeof(value))
std::cout << value << std::endl;

std::ifstream infile("out", ios::binary);
uint32_t value;
infile.read(reinterpret_cast<char*>(&value), sizeof(value))
std::cout << value << std::endl;

Super, so funktioniert es!
Hab den Aufruf jetzt auch in eine Funktion ausgelagert.

Vielen Dank!