Binäre Datei auslesen

Diese Seite verwendet Cookies. Durch die Nutzung unserer Seite erklären Sie sich damit einverstanden, dass wir Cookies setzen. Weitere Informationen

  • Binäre Datei auslesen

    Hallo,

    ich würde gerne mal wissen,wie ich eine binäre datei in c auslese.ich weiss dass es funktionen gibt,allerdings ist mir das noch ein wenig schleierhaft.

    ich habe also eine datei im binärformat vorliegen ( hab ich eigentlich garnicht,was mich zu meiner nächsten frage bringt : wie erzeuge ich so eine datei.?wäre nützlich für spätere testzwecke..) und möchte diese nun in einem c programm auslese und zeichenweise analysieren.

    wie würde ich das nun tun?
    wie darf ich mir so eine binärdatei genau vorstellen? eine einfache textdatei mit nullen und einsen? was unterscheidet sie dann von einer TEXTdatei mit nullen und einsen?...ich weiss dass in einer textdatei die nullen und einsen ascii codiert sind.. wie aber kann ich dann die binäre datei auf dem bildschirm sehen/mir anzeigen lassen?


    lg und danke

    scratchy

  • Hi Scratchy,

    auslesen kannst du die genauso wie eine Text-Datei. Du musst nur beim Mode ein "b" für binary angeben.

    Und auf der untersten Ebene endet jede Datei in Einsen und Nullen. Der Unterschied ist, dass eine binär Datei nicht nur lesbaren Zeichen enthält (ASCII Codes) sondern auch Steuerzeichen. Wenn du eine binär Datei also mit einem Editor öffnest, der die als ASCII darstellen will, siehst du nur kryptischen Scheiß. Da hilft dann nur ein Hex-Editor oder ein Programm was die Steuerzeichen interpretieren kann (z.B. Photoshop bei .psd oder .jpg Dateien).

    Gruß,
    X-Eon

  • so.. ich nochmal...

    irgendwie mag mich mein programm nicht.

    ich habe also schön brav ein programm geschrieben,mir alle möglichen seiten zu "fread" und "fwrite" durchgelesen,aber irgendwie möchte mein programm mir einfach keine binäre datei erzeugen,geschweige denn die daten dann wieder hübsch mit "fread" auslesen...

    fwrite schreibt mir meine eingabe ganz normal formatiert in eine datei, weit und breit keine 1 oder 0 zu sehen... was mache ich denn bitte falsch?

    hier ein codeausschnitt:

    Quellcode

    1. y=fwrite(&a[0],sizeof(char),(strlen(a)-1),datei_aus); /*datei_aus = datei in die fwrite schreiben soll*/
    3. printf("%d",y); /*hier hab ich mir den rückgabewert von fwrite ausgeben lassen(erfolgreich eingelesene byte),stimmte auch alles soweit*/
    5. fclose(datei_aus);
    7. datei2=fopen("binaer.bin","rb");
    9. k=0;
    10. while(!feof(datei2)){
    11. fread(&a[k],sizeof(char),(strlen(a)-1),datei2);
    12. k++;
    13. }
    Alles anzeigen


    ich glaub es is schon spät und ich seh vor lauter bäumen den wald nicht mehr...trotzdem wär ich um jede hilfe dankbar.

    lg * schon mal vorsorglich kopf@wand hau*

  • ich weiß nicht ob dir ganz klar ist, was ne binärdatei ist... Wenn du in eine Datei nur Ascii-Zeichen schreibst (selbst im binärmodus) kommt da trotzdem ne Datei raus, die jeder Texteditor problemlos interpretieren kann. Um die Einsen und Nullen zu sehen brauchst du spezielle Software (oder du programmierst es selbst), wobei man binärdaten normalerweise eher im Octal oder Hexadezimalformat betrachtet.

  • mhh...

    achso... also is quasi ne binärdatei das kauderwelsch was ich immer sehe ,wenn ich zb aus spass mal eine exe im texteditor anseh...

    also die sache ist die :

    ich muss einen dissassembler bauen. ich bekomme von jemandem eine .bin und soll diese dann in assemblercode (16bit befehl = 4 bit opcode und 3x4 bit register)rückübersetzen.. so weit so gut...

    also müsst ich theoretisch immer zwei ascii zeichen einlesen ,weil ascii zeichen ja 8 bit lang sind, und diese dann in binärcode "zurückrechnen" um die bitfolge anschließend zu interpretieren ,richtig?


    lg

    ps: aber warum funktioniert mein code nun nicht richtig? sprich warum macht "fwrite" was ich möchte und "fread" macht nichts?=)

  • Quellcode

    1. fread(&a[k],sizeof(char),(strlen(a)-1),datei2);

    ich weiß nicht, wie du a initialisierst, aber wenn a quasi der leere String ist, bevor du fread aufrufst, liefert strlen(a) 0... wenn du davon jetzt noch eins abziehst und der funktion übergibst, hab ich keine Ahnung, was dann passiert.. ;)
    Den fread aufruf find ich eh etwas seltsam... die Schleife erweckt den eindruck, du wolltest das file char-weise auslesen(was erstmal kein Problem ist). Aber dann macht das strlen(a)-1 als Anzahl der gelesenen chars im fread aufruf irgendwie keinen Sinn... Vieleicht überseh ich auch einfach was ;)

  • Was du suchst, nennt man "Unformatierte Ein/Ausgabe". Die Standartbibliothek bietet dafür in den Klassen i/o-stream, i/o-fstream, fstream u.a. die Methoden write() und read(). Ein Beispiel:

    Quellcode

    1. // serialize.hpp:
    3. #ifndef SERIALIZE_HPP
    4. #define SERIALIZE_HPP
    5. #include <fstream>
    6. #include <cstdio>
    8. using std::fstream;
    10. struct FileTable {
    11. char key[40];
    12. char value[40];
    13. unsigned int id;
    14. };
    16. class Serialize {
    18. private:
    19. fstream fStream;
    21. public:
    22. Serialize(const char*);
    23. ~Serialize();
    24. void Write(FileTable&);
    25. int Read(FileTable&);
    26. void SeekHome();
    28. };
    30. #endif
    32. // ----------------------------------------------------------------------------
    34. //serialize.cpp
    36. #include "serialize.hpp"
    38. using namespace std;
    40. Serialize::Serialize(const char *fileName) {
    41. fStream.open(fileName, ios_base::in | ios_base::out | ios_base::trunc);
    42. }
    44. void Serialize::Write(FileTable &table) {
    45. fStream.write((char *) &table.id, sizeof(int));
    46. fStream.write(table.key, sizeof(char) * 40);
    47. fStream.write(table.value, sizeof(char) * 40);
    48. }
    50. int Serialize::Read(FileTable &table) {
    51. fStream.read((char *) &table.id, sizeof(int));
    52. fStream.read((char *) table.key, sizeof(char) * 40);
    53. fStream.read((char *) table.value, sizeof(char) * 40);
    54. return fStream.tellg();
    55. }
    57. void Serialize::SeekHome() {
    58. fStream.seekg(0, ios_base::beg);
    59. }
    61. Serialize::~Serialize() {
    62. fStream.close();
    63. }
    65. // ----------------------------------------------------------------------
    67. // main.cpp
    69. #include <iostream>
    70. #include "serialize.hpp"
    72. using namespace std;
    74. int main(int argc, char **argv) {
    75. Serialize s1("test.txt");
    76. FileTable t1;
    77. t1.id = 2;
    78. sprintf(t1.key, "%-39s\0", "Name");
    79. sprintf(t1.value, "%-39s\0", "Hakon");
    80. s1.Write(t1);
    83. s1.SeekHome();
    85. FileTable t2;
    87. if(s1.Read(t2) >= 0) {
    88. cout << t2.id << endl;
    89. cout << t2.key << endl;
    90. cout << t2.value << endl;
    91. }
    92. else {
    93. cout << "EOF!" << endl;
    94. }
    96. return 0;
    97. }
    Alles anzeigen


    Viel Glück! ;)