Wie lese ich den BINÄRCODE einer Datei aus?

[Cleverclimber]

Also hallo alle zusammen...
Ich steh schon seit längerem vor einem (aus meiner sicht :???: ) größeren problemchen.... :twisted:
Ich müsste für ein Program den binären Code einer Dateiu auslesen können und wenn es ginge diesen auch wieder abspeichern.
Wer mir helfen könnte:
SCHREIBT UND HELFT MIR!!! :wall:
thx a lot :cheers:

[SirThornberry]

dafür ist die Klasse TFilestream supi geeignet. Hier ein Beispiel:

Delphi-Quellcode:

var LStream: TFileStream;
    LBuffer: String;
begin
  SetLength(LBuffer, 10);
  LStream := TFileStream.Create(DeinDateiname, fmOpenReadWrite);
  //10 Zeischen aus der Datei lesen
  LStream.Read(LBuffer[1], 10);
  //zurück an position 0 springen
  //10 Zeischen zurück schreiben
  LStream.Write(LBuffer[1], 10);
  LStream.Free;
end;

zwischen dem lesen und dem schreiben kannst du natürlich den Buffer ändern.

[Daniel G]

Da wir das erst vor Kuzem hatten:

Änder mal deinen Titel. Hilfe brauch'n 'se hier alle und ein Fragezeichen langt in der deutschen Sprache bereits.

BTW:

Willkommen in der DP... :party: :dp:

[Cleverclimber]

joh danke ging ja fix.... habs noch nit ausprobiert werds aber tun.... nur bnoch was... das mit dem Titel des Themas ändern wie geht das??? :oops:
Und danke für deinen willkommensgruß...
:cyclops:

[Daniel G]

Zitat:

Zitat von Cleverclimber

das mit dem Titel des Themas ändern wie geht das???

Im ersten Beitrag auf http://www.delphipraxis.net/template.../icon_edit.gif klicken ;)

[Cleverclimber]

Danke :wink:


Aber um nochmal auf mein Problem zurückzukommen.... so wie das jetzt ist ließt der mir (bei *.txt-files) immer nur den Text aus und bei andern (*.bmp) kommt dann einfach nur eine sinnlose Buchstaben kombination. :pale:
Meine Frage war aber wie ich den BINÄRCODE auslesen kann, also die Kombination der 1 und 0, mit der die datei eigentlich auf der festplatte geschpeichert ist.
Mein wunschausgabeergebnis wäre ein String mit einer Zahlenkombination die nur aus 1 und 0 besteht also zum Beispiel :arrow: '011010101011101000010001000101010000010100'
Also irgendwie war das noch nicht das richtige, das hätte ich auch mit

Delphi-Quellcode:

var text:Tstringlist;
begin
  text:=TStringlist.Create;
  text.LoadfromFile(Dateiname);
end;

machen können.
Aber trotzdem schon mal danke. :thumb:

[SirThornberry]

das müsstest du dir dann selbst anhand der ausgelesenen Zeischen darstellen. Bits kann man nicht einzeln auslesen. man kann nur ganze Bytes lesen. Und dann müsste man eben prüfen welche Bits gesetzt sind und drauf dann die 0en und 1en machen.

[ichbins]

du kannst den Filestream verwenden, dann geht es nur etwas anderst:

Delphi-Quellcode:

var LStream: TFileStream;
    buf:array of byte;
begin
  SetLength(LBuffer, 10);
  LStream := TFileStream.Create(DeinDateiname, fmOpenReadWrite);
  //10 Zeischen aus der Datei lesen
  LStream.Read(LBuffer[1], 10);
  //zurück an position 0 springen
  //10 Zeischen zurück schreiben
  LStream.Write(LBuffer[1], 10);
  LStream.Free;
end;

//der Inhalt des Array of Byte beinhaltet nach dem Lesen die ersten 10 Zeichen der Datei als Byte-Zahlen, also 0-255. Die kannst du dann noch weiter in 1en und 0en oder alternativ Hex-Zeichen zerlegen:

Delphi-Quellcode:

function hex(b:byte):string;
var
  hexes:string='0123456789ABCDEF';
begin
  result:=hexes[1+ (b div 16)]+ hexes[1+(b mod 16)];
end;

es gibt noch unendlich viele andere Möglichkeiten, den Code auszulesen, ich persönlich halte den filestream nicht für die eleaganteste.

z.B. gibts da noch die file:

Delphi-Quellcode:

var
  f:file of {jederbeliebigeTyp ausser Strings und Klassen, wir nehemn file of byte, um einzelne 1-Byte-große zahlenwerte 
auszulesen} byte;
  r:integer;
  buf:array [0..1023] of byte;
begin
  assignfile(f,dateiname);
  //jetzt Datei öffnen:
  reset(f); //um existierende datei zu öffnen
  rewrite(f); //um existierende datei zu überschreiben oder neue zu erstellen
  //jetzt lesen/schreiben
  blockread(f {Dateivariable, aus der gelesen wird},buf{buffer-Speichervariable in die gelesen wird},1024{anzahl der zu lesenden Bytes},r{Hier eine Integervariable angeben, in der nach dem lesen gespeichert ist wie viel der zu lesenden Bytes tatsächlich gelesen wurden});
  seek(f,position); //springe in der Datei an eine bestimmte Position (0  = Anfang, filesize(F) = Ende, 1200 = hinter dem 1200. Byte in der Datei)
  blockwrite(f {Dateivariable, in die geschrieben wird},buf{buffer-Speichervariable aus der geschrieben wird},1024{anzahl der zu schreibenden Bytes},r{Hier eine Integervariable angeben, in der nach dem schreiben gespeichert ist wie viel der zu schreibenden Bytes tatsächlich geschrieben wurden});
  
  filepos(f) //gibt die Position zurück an der die Datei sich gerade befindet
  //letztendlich Datei wieder schliessen
  closefile(f);
end;

[Dust Signs]

@ichbins: Wäre IntToHex nicht einfacher?

Dust Signs

[ichbins]

Zitat:

Zitat von Dust Signs

@ichbins: Wäre IntToHex nicht einfacher?

Dust Signs

kennichnicht :wall:

[Cleverclimber]

Zitat:

Zitat von ichbins

du kannst den Filestream verwenden, dann geht es nur etwas anderst:

Delphi-Quellcode:

var LStream: TFileStream;
    buf:array of byte;
begin
  SetLength(LBuffer, 10);
  LStream := TFileStream.Create(DeinDateiname, fmOpenReadWrite);
  //10 Zeischen aus der Datei lesen
  LStream.Read(LBuffer[1], 10);
  //zurück an position 0 springen
  //10 Zeischen zurück schreiben
  LStream.Write(LBuffer[1], 10);
  LStream.Free;
end;

//der Inhalt des Array of Byte beinhaltet nach dem Lesen die ersten 10 Zeichen der Datei als Byte-Zahlen, also 0-255. Die kannst du dann noch weiter in 1en und 0en oder alternativ Hex-Zeichen zerlegen:

Delphi-Quellcode:

function hex(b:byte):string;
var
  hexes:string='0123456789ABCDEF';
begin
  result:=hexes[1+ (b div 16)]+ hexes[1+(b mod 16)];
end;

War der erste Quellcode nicht mit dem hier gerade identisch, bis auf dei Variabeln?? Und außerdem wird das arrey gar nicht in der function verwendet :? also von daher... ich weiß nicht... und das mit dem umwandel hab ich nicht ganz gechekt... :|

[Ratte]

Der erste QT verwendet Byte als buffer, keine Strings. Und der zweite wandelt ein übergebenes Byte in den passenden Hexwert um.
mfg,
Ratte

[Cleverclimber]

Joh danke aan alle.... Wie das jetzt aber genau mit dem abspeichern funktioniert check ich leider immer noch nicht :wall: sry... Kann mir das Viellleciht jemand erklären? :wiejetzt:
Ich hab das Array mit 1024 (ACH SO WARUM 1024??) inhalten... wie kann ich die einfach wieder auf die festplatte laden??

Delphi-Quellcode:

var
  f:file of {jederbeliebigeTyp ausser Strings und Klassen, wir nehemn file of byte, um einzelne 1-Byte-große zahlenwerte
auszulesen} byte;
  r,i:integer;
begin
  assignfile(f,dateiname);
  //jetzt Datei öffnen:
  reset(f); //um existierende datei zu öffnen
  //jetzt lesen/schreiben
  blockwrite(f {Dateivariable, aus der gelesen wird},buf{buffer-Speichervariable in die gelesen wird},1024{anzahl der zu lesenden Bytes},r{Hier eine Integervariable angeben, in der nach dem lesen gespeichert ist wie viel der zu lesenden Bytes tatsächlich gelesen wurden});

  closefile(f);
end;

geht das so?? :gruebel:
Also wäre klasse wenn das jemand sagen könnte.... So wies da steht gehts aufjedenfall nicht!
Und nochmal danke an alle! :thumb:

[ichbins]

yep, so gehts.

die grünen Kommentare kannst du natürlich allesammt rauslöschen, waren nur zur Erklärung gedacht ;)

das geht aber nur wenn die Datei die du öffnen willst auch existiert. Ansonsten rewrite statt reset benutzen.

1024 Bytes einfach weil das genau ein Kilobyte ist. 4096 (4 Kilobyte) ist auch eine gängige Größe aber du kannst beliebige Größen bis (theoretisch) 2 GB verwenden.


also, ich erklärs nochmal:

Delphi-Quellcode:

file of byte

heisst, dass du eine Datei hast, die immer in Byte-Werten (der Typ Byte ist in Delphi eine Zahlenvariable der Größe ein Byte (0..255)) liest und schreibt. du könntest auch file of integer oder file of char nehmen.

Delphi-Quellcode:

assignfile(f,dateiname)

heisst, dass du der Datei einen Dateinamen zuweist. Die Datei wird aber noch nicht geöffnet.

Delphi-Quellcode:

reset(f)

heisst, dass die Datei geöffnet wird. Das geht nur wenn die Datei schon existiert.

Delphi-Quellcode:

rewrite(f)

heisst, dass die Datei neu erstellt und dann geöffnet wird. Falls sie schon existiert, wird der Inhalt gelöscht.

Delphi-Quellcode:

blockwrite(f,buf,bytecont,writtenbytes)

heisst, dass in die Datei f bytecont Bytes aus dem Buffer buf geschrieben werden, und die Anzahl der Tatsächlich geschriebenen Bytes in der Variable writtenbytes gespeichert wird.

Delphi-Quellcode:

blockread(f,buf,bytecount,readbytes)

heisst, dass aus der Datei f bytecount Bytes in den Buffer buf eingelesen werden, und die Anzahl der Tatsächlich gelesenen Bytes in der Variable readbytes gespeichert wird.

Delphi-Quellcode:

closefile(f)

heisst, dass die Datei f geschlossen wird. Solltest du immer am Ende machen. Sonst ist der Zugriff auf die Datei durch andere Programme oder ein erneutes Öffnen gesperrt.

dann gibt es noch einige andere wertvolle Funktionen:

Delphi-Quellcode:

filesize(f)

gibt die Dateigröße der Datei zurück.

Delphi-Quellcode:

seek(f,position)

führt dazu, dass der Dateipositionszeiger (da wo blockread oder blockwrite anfangen zu arbeiten wenn du sie ausführst, nach dem Öffnen der Datei immer 0) auf die neue Position springt.

Delphi-Quellcode:

eof(f)

gibt zurück, ob der Dateipositionszeiger am Ende der Datei ist.

Delphi-Quellcode:

filepos(f)

gibt die Position des Dateipositionszeigers zurück.

[Ferber]

BlockRead und BlockWrite sind gut und schnell, haben aber den Nachteil das sie nur 'Portionen' lesen und schreiben.
Hat wieder einen Vorteil bei wahnsinnig grossen Dateien.

IMHO am elegantesten, und sauschnell, ist ein MemoryStream.

Delphi-Quellcode:

procedure TForm1.Button1Click(Sender: TObject);
var ms:TMemoryStream;
begin
  ms:=TMemoryStream.Create;
  ms.LoadFromFile('aFileName');

// Sieh Dir mal in der OH an:
// ms.Memory;
// ms.Read;
// ms.Write;

  ms.SaveToFile('aFileName');
  ms.Free;
end;

:wink:

[ichbins]

aber da wird die komplette Datei geladen. Wenn er dagegen nur 1 KB lesen will ist es so viel besser.