spieleprogrammierer.de - Forum und Wiki zur Spieleprogrammierung und Spieleentwicklung

C-/C++-Quelltext

 // So könntest du die Datei komplett auslesen (wohl eher ein Minimalbeispiel):
void Highscores::loadHighscores()
{
    ifstream data ("Highscores.bin", ios::in | ios::binary);

    if(data.fail())
    {
        cout << "Konnte Datei nicht oeffnen." << endl;
    }
    else
    {

        data.seekg (0, ios::end); // Zeiger zum Ende der Datei
        int length = data.tellg(); // Länge der Datei ermitteln
        data.seekg (0, ios::beg); // Zeiger wieder zu Anfang

        char * buffer = new char [length]; // Speicher zum Auslesen reservieren

        data.read(buffer, length); // Komplette Datei in Buffer speichern
        data.close(); // Datei schliesen

        cout << buffer << endl; // Buffer ausgeben


        delete[] buffer;
    }

}

C-/C++-Quelltext

template <typename _T>
std::ofstream& write_binary(_T const& data, std::ofstream& out) 
{ return out.write(reinterpret_cast<const char*>(&data), sizeof (_T)), out; }

template <>
std::ofstream& write_binary(std::string const& data, std::ostream& out)
{
    const std::size_t length(data.length() + 1);
    out.write(reinterpret_cast<const char*>(&size), sizeof (std::size_t));
    out.write(data.c_str(), length);
    return out;
}

int main()
{
    std::ofstream file_stream("output.dat", std::ios_base::binary);
    write_binary(std::string("sample"), write_binary(15, file_stream));
}

C-/C++-Quelltext

// statt
void Highscores::save(ofstream data, std::string content)

// mit Referenz
void Highscores::save(ofstream &data, std::string content)

// Statt write direkt aufzurufen, einfach die Funktion save()
save(data,Punkte.name);
save(data,Punkte.date);
save(data,toCharArray(Punkte.points));

C-/C++-Quelltext

template <typename _T> // hiermit sagen wir das wir ne Funktionsschablone anlegen sollen, d.h. das er anstelle unseres _Ts später immer den entsprechenden Variablentyp setzen soll (std::string, int, ...)
std::ofstream& write_binary(_T const& data, std::ofstream& out) // wir bekommen übergeben was geschrieben werden soll (data) und worein das geschehen soll (out), weils schonmal ganz praktisch sein kann, geben wir unseren Stream auch wieder zurück (kannst z.B. dann einfach gucken (if (write_binary(...)), wodurch der dann die fehlerstates des strings abfragt!)
{ 
    out.write(reinterpret_cast<const char*>(&data), sizeof (_T)); // damit casten wir die daten die wir bekommen in nen char-Zeiger (wies die funktion verlangt) und übergeben noch die größe der Daten
    return out; 
}

template <> // Nun gibt es einen Sonderfall, der anders gespeichert wird, der std::string. D.h. wir spezialisieren unsere Schablone 
std::ofstream& write_binary(std::string const& data, std::ostream& out) // Und geben anstelle des _Ts den entsprechenden Typ an, den wir speziell behandeln wollen.
{
    const std::size_t length(data.length() + 1); // die länge des Strings + Null-Terminierungszeichen
    out.write(reinterpret_cast<const char*>(&size), sizeof (std::size_t)); // Die größe speichern wir
    out.write(data.c_str(), length); // Und danach den String selbst, eigtl. sizeof (char_type) * length, aber sizeof (char) nehm ich mal als == 1 an ;)
    return out;
}