Tutorial gesucht

Stromberg

Kennt jemand von euch ein Tutorial (möglichst deutsch) über Streams im binär Modus. Ich hatte schon mal eines gesehen welches diesen Aspekt behandelt, finde es aber nicht mehr.
Ich möchte halt wissen, wie ich einen Binärcode in die jeweilige Datei einlese/auslese und wie ich dass am besten mit <bitset> verknüpfen kann. Vll. kennt ja jemand ein gutes Tutorial.

Gruß
Stromberg

pumuckl

Mit der Einschränkung "möglichst auf Deutsch" kommst du nicht weit. Je spezieller die Themen, desto seltener findet sich ordentliche Literatur auf deutsch, das meiste wird auf englisch geschrieben. Vieles von den Deutschen Sachen sind übersetze englische Dinge, deshalb häufig schon etwas älter bzw. veraltet, und meistens auch nicht besonders gut übersetzt. Daher wirst du um Englisch nicht drumherum kommen, wenn du dich ersnthaft mit solchen Themen beschäftigen willst. Und mit ein bisschen Übung ist das dann auch nicht so wild. Ansonsten schau mal hier und such dir eines der Tutorials aus, oder mehrere. Möglichst auf englisch

Stromberg

Mh also anscheinend geht es ja auf diese Art udn Weise:

char A[7] = "BlaBla";
fstream binary_file("/home/andi/BI.xlz", ios::out | ios::binary);
binary_file.write(reinterpret_cast<char *>(&A), 6);
binary_file.close();

char B[7];
binary_file.open("/home/andi/BI.xlz", ios::in | ios::binary);
// <-- tellp();
binary_file.read(reinterpret_cast<char *>(&B),6);
binary_file.close();
cout << B << endl; // -> BlaBlaBlaBla

1. Warum wird "BlaBlaBlaBla" ausgegeben? Und nicht "BlaBla"?
2. Ganz mysteriös: Wenn ich nachdem ich das file ein 2. mal geöffnet habe "binary_file.tellp()" dazwischen schiebe, funktioniert es plötzlich und es kommt ganz normal einmal "BlaBla"
3. Anscheinend ist das so üblich mit dem "reinterpret_cast" oder? Bisher habe ich nur immer überall gelsen, man solle auf keinen Fall reinterpret_cast in seinem Proggramm verwenden, weil dieser so gefährlich sei?!

Gruß
Stromberg

Maxi

B ist nicht nullterminiert?

Stromberg

Ja klar natürlich, jetzt funktionierts:

#include <iostream>
#include <vector>
#include <string>
#include <bitset>
#include <fstream>

using namespace std;

int main()
{

    char A[7] = "BlaBla";
    fstream binary_file("/home/andi/BI.xlz", ios::out | ios::binary);
    binary_file.write(reinterpret_cast<char *>(&A), 6);
    binary_file.close();

    char B[7];
    binary_file.open("/home/andi/BI.xlz", ios::in | ios::binary);
    binary_file.read(reinterpret_cast<char *>(&B),6);
    B[6] = '\0';
    binary_file.close();
    cout << B << endl;

    return 0;
}

Manchmal sieht man den Wald vor lauter Bäumen nicht
Dankeschön

Gruß
Stromberg

EDIT:
Noch was, und zwar zur allgemeinen Funktionsweise von reinterpret_cast, ich kann das zwar jetzt schön anwenden, und so eine Binärdatei erstellen, was aber genau passiert verstehe ich nicht?! In meinem Buch habe ich gelesen: "reinterpret_cast: Neuinterpretation des Bitmusters auf tiefer Ebene". Nur was soll das heißen? Irgendwie wandelt reinterpret_cast mein "BlaBla" in einen Binärcode um und schreibt ihn dann in eine Datei oder?
Und was soll eigentlich der Adressoperator "&" vor dem B? Kann mir jemand die Funktionsweise erläutern?

Nexus

A hat ein bestimmtes Bitmuster, dessen Interpretation sich je nach Datentyp (und oft auch Plattform) unterscheidet. Zum Beispiel kann diese einem Zweierkomplement bei int und Mantisse/Exponent bei float entsprechen. Mit reinterpret_cast sagst du dem Compiler, er soll die Typprüfung umgehen und den Speicherbereich als Zieltyp neu interpretieren. Der Cast tut selbst also nichts, aber er bereitet den nachfolgenden Zugriff (der je nach Typ anders aussieht) auf den Speicher vor.

reinterpret_cast<char*> deshalb, weil du auf die einzelnen Bytes ( char s) des Objekts zugreifen willst. Wenn du den resultierenden char* -Zeiger dereferenzierst (z.B. mit dem Indexoperator), hast du genau das.

Stromberg

Noch eine Frage, was ist denn am schnellsten 1 Byte oder 8 Byte oder....schreiben? Gibt es da einen optimalen Wert oder ist dass egal?

Gruß
Stromberg

EDIT:
Und noch was, kann mir jemand sagen wie ich Zahlen in eine Binärdatei schreibe, Zeichen sind ja kein Problem mehr, aber wie geht dass ganze mit reinen Zahlen bzw. sogar eventuell reinen Binärzahlen?

SeppJ

Ein-/Ausgabe ist sowieso total lahm, der Flaschenhals ist dabei das Ausgabegerät selbst. Optimierung der Ausgabemethode ist daher irrelevant. Sieh halt bloß zu, dass du nicht dauernd die Puffer synchronisierst (z.B. durch schließen und wieder öffnen eines Filestreams, eventuell auch durch Vermeidung von flush, weiß nicht genau ob letzteres bei Dateien auch lahm ist). Ansonsten kannst du als Dauemnregel nehmen, dass mehr Daten auf einmal im Durchschnitt schneller geschrieben werden, weil eventueller Overhead nur einmal anfällt.

Stromberg

Hat jemand mein EDIT vom letzten Beitrag gelesen?

SeppJ

Stromberg schrieb:

Hat jemand mein EDIT vom letzten Beitrag gelesen?

Ja, aber ich verstehe nicht was du meinst. Beziehungsweise wo da der Unterschied zu Zeichen sein soll. Und was eine Binärzahl sein soll. Also kurz gesagt: Ich verstehe deine Frage nicht.

Stromberg

Bis jetzt habe ich immer z.B. Wörter eingelesen oder einzelne Buchstaben. Wie kann ich aber Zahlen/Binärzahlen in eine Datei einlesen z.B. 1233 / 10011010001.
So etwas sähe doch von der Binär Datei dann auch schon ganz anderst aus. bei Wörtern belegt ja jeder Buchstabe ein Byte, aber bei 1233 würden ja auf einmal 11 bit belegt werden.
Kann ich so eine Zahl auch mit der Funktion write und dem reinterpret_cast in die Binär Datei reinschreiben oder gibt es da eine andere Funktion?

Braunstein

Hallo,

Du kannst alles binär schreiben. Das sieht dann z.Bsp. so aus

int i = 4;
ofstream binary_file("/home/andi/BI.xlz", ios::binary);
binary_file.write(reinterpret_cast<const char *>(&i), sizeof(i));

Das inlesen dann analog.

int i;
ifstream binary_file("/home/andi/BI.xlz", ios::binary);
binary_file.read(reinterpret_cast<char *>(&i), sizeof(i));

Warum willst du eigentlich alles binär schreiben?

padreigh

Wenn du dir write mal genau ansiehst, wirst du merken das das immer mindestens 1 byte == 8 bit speichert. Wenn du zahlen speichern willt die größer als 1 byte sind solltest du mal nach endianess googeln. je nach rechner kann
deine 1234 als 00000100 11010001 oder 11010001 00000100 gespeichert werden (nur wichtig wenn du dich nicht auch selbst ums einlesen kümmerst...

Braunstein

Wem willst du das jetzt sagen?
Klar kann die Endianess ein Problem werden wenn man Binärdateien zwischen verschiedenen Systemen austauschen will. Das sollte man aber sowieso nicht machen. Mit der Größe der Datentypen hat man dann ja auch ein Problem.

Oder man machts wie bei Qt (QDataStream) wo alle relevanten Informationen gleich mit gespeichert werden so das auch die Kompatibilität zwischen unterschiedlichen Systemen wieder da ist.

Stromberg

Was haltet ihr von der Funktion?

bool BinaerEingabe(const vector<string> temp, const string &filename)
{
    ofstream data(filename.c_str(), ios::out | ios::binary);
    for(vector<string>::const_iterator iter = temp.begin(); iter != temp.end(); ++iter)
    {
        for(string::size_type i = 0; i<iter->size(); ++i)
        {
            char buffer = iter->at(i);
            data.write(reinterpret_cast<char *>(&buffer), 1);
            if(!data.good()) return false;
        }
    }
    data.close();
    return true;
}

Ist es schlecht dass ich immer nur 1Byte einlese (also von der Schnelligkeit)? Wenn ich mehr Zeichen einlese z.B. 8Byte dann müsste ichs aber irgendwie wieder hin bekommen dass der String aufgeht, oder was soll ich machen wenn es am Ende bei der letzten Schreiboperation z.B. nur noch 3 Zeichen gibt, ich aber eigentlich 8 benötige?

@Braunstein
Wollte so was nur mal ausprobieren, mir wars zu langweilig immer nur in .txt Dateien zu schreiben. Was binär abzuspeichern sieht cooler aus, und es kann nicht jeder gleich auf Anhieb lesen.

Gruß
Stromberg