C++ Academy · Lektion

Binäre Datei-Ein-/Ausgabe

Rohe Bytes lesen und schreiben

Binäre Datei-Ein-/Ausgabe ist eine kostenlose C++ Academy-Lektion auf CoddyKit. Dies ist Lektion 3 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des C++ Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der C++ Academy-Kurs umfasst insgesamt 4 Lektionen.

Text und Binärdaten

Der Textmodus schreibt lesbare Zeichen; der Binärmodus schreibt die rohen Bytes von Objekten exakt so, wie sie im Speicher liegen. Öffnen Sie die Datei mit std::ios::binary.

#include <iostream>
#include <fstream>

int main() {
    int value = 12345;
    std::ofstream out("v.bin", std::ios::binary);
    out.write(reinterpret_cast<const char*>(&value), sizeof(value));
    std::cout << "wrote " << sizeof(value) << " bytes\n";
    return 0;
}

write übernimmt Bytes

write(ptr, n) gibt n rohe Bytes ab der Adresse ptr aus. Dazu wandeln Sie die Objektadresse in const char* um.

#include <iostream>
#include <fstream>

int main() {
    double d = 3.14;
    std::ofstream out("d.bin", std::ios::binary);
    out.write(reinterpret_cast<const char*>(&d), sizeof(d));
    out.close();
    std::cout << "saved a double\n";
    return 0;
}

read stellt Bytes wieder her

read(ptr, n) lädt n Bytes in das Objekt an der Adresse ptr und macht damit einen binären Schreibvorgang rückgängig.

#include <iostream>
#include <fstream>

int main() {
    int original = 777;
    std::ofstream("i.bin", std::ios::binary).write(reinterpret_cast<const char*>(&original), sizeof(original));
    int loaded = 0;
    std::ifstream in("i.bin", std::ios::binary);
    in.read(reinterpret_cast<char*>(&loaded), sizeof(loaded));
    std::cout << loaded << '\n';
    return 0;
}

Eine POD-Struktur schreiben

Plain-Old-Data-Strukturen (ohne Zeiger und mit Membern fester Größe) können als ein zusammenhängender Byt eblock gespeichert und wieder geladen werden.

#include <iostream>
#include <fstream>

struct Record { int id; double balance; };

int main() {
    Record r{1, 99.5};
    std::ofstream out("rec.bin", std::ios::binary);
    out.write(reinterpret_cast<const char*>(&r), sizeof(r));
    std::cout << "struct saved\n";
    return 0;
}

Die Struktur zurücklesen

Beim Lesen wird die gesamte Struktur mit einem einzigen Aufruf von read wiederhergestellt.

#include <iostream>
#include <fstream>

struct Record { int id; double balance; };

int main() {
    Record w{42, 250.0};
    std::ofstream("r2.bin", std::ios::binary).write(reinterpret_cast<const char*>(&w), sizeof(w));
    Record r{};
    std::ifstream in("r2.bin", std::ios::binary);
    in.read(reinterpret_cast<char*>(&r), sizeof(r));
    std::cout << r.id << ' ' << r.balance << '\n';
    return 0;
}

Ein Array schreiben

Sie können ein gesamtes Array mit einem einzigen Aufruf schreiben, indem Sie seine Gesamtgröße in Bytes übergeben.

#include <iostream>
#include <fstream>

int main() {
    int arr[5] = {1, 2, 3, 4, 5};
    std::ofstream out("arr.bin", std::ios::binary);
    out.write(reinterpret_cast<const char*>(arr), sizeof(arr));
    std::cout << "wrote " << sizeof(arr) << " bytes\n";
    return 0;
}

Das Array zurücklesen

Lesen Sie dieselbe Anzahl Bytes in ein Array derselben Größe ein.

#include <iostream>
#include <fstream>

int main() {
    int src[5] = {10, 20, 30, 40, 50};
    std::ofstream("a2.bin", std::ios::binary).write(reinterpret_cast<const char*>(src), sizeof(src));
    int dst[5] = {};
    std::ifstream in("a2.bin", std::ios::binary);
    in.read(reinterpret_cast<char*>(dst), sizeof(dst));
    for (int x : dst) std::cout << x << ' ';
    std::cout << '\n';
    return 0;
}

Positionen ansteuern

seekg (get) und seekp (put) verschieben die Lese-/Schreibposition und ermöglichen den wahlfreien Zugriff auf die Datei.

#include <iostream>
#include <fstream>

int main() {
    int data[3] = {100, 200, 300};
    std::ofstream("seek.bin", std::ios::binary).write(reinterpret_cast<const char*>(data), sizeof(data));
    std::ifstream in("seek.bin", std::ios::binary);
    in.seekg(sizeof(int)); // skip to second int
    int second; in.read(reinterpret_cast<char*>(&second), sizeof(second));
    std::cout << second << '\n';
    return 0;
}

Die Position abfragen

tellg und tellp geben die aktuelle Position zurück und eignen sich zum Ermitteln der Dateigröße oder von Offsets.

#include <iostream>
#include <fstream>

int main() {
    int data[4] = {1, 2, 3, 4};
    std::ofstream("tell.bin", std::ios::binary).write(reinterpret_cast<const char*>(data), sizeof(data));
    std::ifstream in("tell.bin", std::ios::binary);
    in.seekg(0, std::ios::end);
    std::cout << "file size: " << in.tellg() << " bytes\n";
    return 0;
}

Warum keine Zeiger

Speichern Sie niemals Objekte mit Zeigern oder std::string direkt als Binärdaten: Sie würden die Zeigeradresse speichern, nicht die Daten, auf die sie zeigt. Serialisieren Sie stattdessen den Inhalt.

#include <iostream>
#include <fstream>
#include <string>

int main() {
    std::string s = "hello";
    std::ofstream out("str.bin", std::ios::binary);
    std::size_t len = s.size();
    out.write(reinterpret_cast<const char*>(&len), sizeof(len));
    out.write(s.data(), len); // write the chars, not the object
    std::cout << "serialized " << len << " chars\n";
    return 0;
}

Einschränkungen der Portierbarkeit

Binäre Speicherlayouts hängen von der Byte-Reihenfolge und den Größen der Datentypen ab. Dateien, die auf einer Plattform geschrieben wurden, lassen sich auf einer anderen möglicherweise nicht korrekt lesen. Definieren Sie daher für den Austausch ein festgelegtes Format.

#include <iostream>
#include <cstdint>

int main() {
    std::int32_t fixed = 1; // fixed-width type for portability
    std::cout << "sizeof int32_t = " << sizeof(fixed) << '\n';
    return 0;
}

Kurztest

Testen Sie Ihr Verständnis der binären E/A.

Zusammenfassung

Sie haben die binäre Datei-E/A kennengelernt:

Öffnen Sie Dateien mit std::ios::binary; verwenden Sie write/read mit reinterpret_cast<char*>
seekg/seekp und tellg/tellp ermöglichen den wahlfreien Zugriff
Speichern Sie Zeiger oder Strings niemals direkt; serialisieren Sie deren Inhalt und achten Sie auf die Byte-Reihenfolge

Als Nächstes lernen Sie, den Stream-Zustand zu prüfen und Fehler zu behandeln.

Häufig gestellte Fragen

Ist die Lektion „Binäre Datei-Ein-/Ausgabe“ kostenlos?

Ja — der vollständige Text von „Binäre Datei-Ein-/Ausgabe“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des C++ Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der C++ Academy-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „Binäre Datei-Ein-/Ausgabe“?

Rohe Bytes lesen und schreiben Du übst C++ Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um C++ Academy zu starten?

Keine Vorkenntnisse erforderlich. C++ Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 3 von 4.

Wie lange dauert die Lektion „Binäre Datei-Ein-/Ausgabe“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser C++ Academy-Lektion Code schreiben und ausführen?

Ja. Jede C++ Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

← Zurück zu C++ Academy