Blockread mal wieder

[dazar_t]

Guten Tag
Mir ist die funktion BlockRead bekannt und so wie ich es nun verstanden habe läuft es so ab :

Delphi-Quellcode:

BlockRead(FILE,BUFFER,WIEVIELE ZEICHEN MAN LESEN WILL);

aber z.B in diesem Code

Delphi-Quellcode:

var
  f,t: file of byte;
  buf: array[1..4096] of byte;
  read: Integer;
begin
  assignfile(f, 'Y:\Datei1.exe');
  assignfile(t, 'C:\Datei1.exe');
  reset(f);
  rewrite(t);
  while not eof(f) do
  begin
    blockread(f, buf, length(buf), read);
    blockwrite(t, buf, read);
    Progressbar1.Position:=round(100*(filesize(t)/filesize(f)));
    Application.ProcessMessages;
  end;
  closefile(f);
  closefile(t);

wird read ja nirgends einen wert zugewiesen wieviele zeichen ließt er den dann und warum ?

[omata]

Liess dir doch einfach mal die Hilfe durch, dann sollte das klar sein.

Delphi-Quellcode:

procedure BlockRead(var F: File; var Buf; Count: Integer [; var AmtTransferred: Integer]);

Wird der gesamte Block übertragen, ist AmtTransferred mit Count identisch.

Ist AmtTransferred kleiner als Count, wurde vor Beendigung der Übertragung das Dateiende erreicht. In diesem Fall gibt AmtTransferred die Anzahl der vollständig gelesenen Blöcke zurück, wenn die Datenblockgröße der Datei größer als 1 ist.

[dazar_t]

danke für deine antwort aber ganz ehrlich ist mir es immer noch nicht ganz klar :(

Weil z.B in dem Code ist ja noch garkein block gelesen ( In diesem Fall gibt AmtTransferred die Anzahl der vollständig gelesenen Blöcke zurück, wenn die Datenblockgröße der Datei größer als 1 ist.)

oder wird dan jeder block zurück gegeben ?

[omata]

Ok, ich versuche es nochmal...

Count ist immer gleich AmtTransferred, am Ende wird AmtTransferred < Count und enthält dann die wirklich gelesene Zeichenanzahl.

[dazar_t]

Also ich habe noch ein tutorial gefunden dort wird dieser Code gezeigt

Delphi-Quellcode:

procedure OpenArchivFile(ArchivName: string; var ArchivFile: ArchivTyp);
var I, q: Integer;
  Size: LongInt;
  AktPos: integer;
  s: string;
  SSize: byte; // Länge des Strings
begin
  ArchivFile.FileStart:=TStringList.Create;
  ArchivFile.FileNames:=TStringList.Create;

  if not FileExists(ArchivName) then Exit;

  AssignFile(ArchivFile.ArchivFile, ArchivName);
  ReSet(ArchivFile.ArchivFile,1);

  { Erste Datei }
  BlockRead(ArchivFile.ArchivFile, SSize, SizeOf(SSize));
  // zuerst wird ausgelesen, wie groß der Dateiname ist
  SetLength(s,SSize);
  // dann wird S diese Länge zugewiesen
  BlockRead(ArchivFile.ArchivFile,s[1],SSize);
  // anschließend kann der Dateiname aus der Archivdatei
  // ausgelesen werden.

  BlockRead(ArchivFile.ArchivFile,Size,SizeOf(Size));
  // die Größe der Datei

  ArchivFile.FileNames.Add(s);
  // der Dateiname
  ArchivFile.FileStart.Add(IntToStr(SSize+SizeOf(SSize)+SizeOf(Size)));
  // wo beginnen die Daten der ersten Datei?

  AktPos:=SSize+SizeOf(SSize)+SizeOf(Size)+size;
  // an welcher Stelle in der Archivdatei befinden wir uns gerade:
  // am Anfang der 2. Datei (+size)

z.B : BlockRead(ArchivFile.ArchivFile, SSize, SizeOf(SSize));
der müsste doch dann einen Block lesen der EIN Byte groß ist oder ?!

Ich glaube ich komme nicht dahinter :oops: :( :?: :freak:

[sirius]

Du hast eine typisierte Datei. Geht da überhaupt BlockRead :gruebel:

[omata]

Da wird der 4 Parameter nicht verwendet. Dann hat man auch diese Information nicht. Ist ja auch ok, der Parameter ist ja optional. Das bedeutet, es wird einfach die Size-Größe aus der Datei gelesen, ferig.

Wie man blockread am besten einsetzen kann, hängt immer davon ab, was man machen will. Schau dir also nicht irgendwelche Beispiele an, sondern schau dir die Delphi-Hilfe an.

[dazar_t]

Ich glaube ich habe einfach meine frage falsch Formuliert. Mich interresiert was z.B bei diesem Code BlockRead(ArchivFile.ArchivFile,SSize,SizeOf(SSize )); Dieses Sizeof(Size) bringt da doch SSize nie eine Zahl zugeorfnet wird. Sorry wenns langsam lästig wird

Habe grade gemerkt das das mit dem READ nicht gemeint war

[omata]

SSize ist der Buffer, in den die Inhalte, die BlockRead liest geschrieben werden.
Damit BlockRead weiss wie groß der Buffer ist, wird dies über sizeof(Buffer) übergeben.

[Nuclear-Ping]

SSize ist ein Byte. Folglich ist SizeOf (SSize) = 1. Also liest er ein Byte. Zusatz: Man kann statt SizeOf (SSize) auch SizeOf (Byte) schreiben. Das wäre das gleiche. Man nutzt deswegen SizeOf, um Plattformkompatibilität zu gewährleisten, da nicht 100% gewährleistet ist, dass auf allen System ein Byte immer 1 groß ist.

In deinem Beispiel oben wird die Größe der zu lesenden Bytes durch die Größe des Arrays vorgegeben. buf: array[1..4096] of byte = length(buf) = 4096.

[dazar_t]

Achsoo damit bin ich doch schonmal ein stück weiter ^^

Aber in diesem Code beispielsweise ließt er immer einen Namen z.B ARCHIV_FILE_NUMMER_1 dieser name wird ja nicht immer ein byte groß sein also warum funktioniert es trotzdem ?

Delphi-Quellcode:

  BlockRead(ArchivFile.ArchivFile, SSize, SizeOf(SSize));
  // zuerst wird ausgelesen, wie groß der Dateiname ist
  SetLength(s,SSize);
  // dann wird S diese Länge zugewiesen
  BlockRead(ArchivFile.ArchivFile,s[1],SSize);
  // anschließend kann der Dateiname aus der Archivdatei
  // ausgelesen werden.

  BlockRead(ArchivFile.ArchivFile,Size,SizeOf(Size));
  // die Größe der Datei

[Nuclear-Ping]

Zitat:

Aber in diesem Code beispielsweise ließt er immer einen Namen z.B ARCHIV_FILE_NUMMER_1 dieser name ...

Was macht er? Schau dir den Code nochmal an. ;)

[dazar_t]

den ganzen code habe ich von : http://www.delphi-treff.de/tutorials...archiv/page/3/
Und da wird erst ausgelsen wie groß der datei name iss dann was der name iss und dann die datei.

[Nuclear-Ping]

Delphi-Quellcode:

BlockRead(ArchivFile.ArchivFile, SSize, SizeOf(SSize));
SetLength(s,SSize);
BlockRead(ArchivFile.ArchivFile,s[1],SSize);

Schau dir den Code doch nochmal an. Erst wird SSize gelesen. SSize enthält danach höchstwahrsch. die Länge des Dateinamens. Dann wird s (<- blöder Name für ne Variable - der Dateiname wahrsch.) gelesen und als Anzahl wieviel er lesen soll, wird SSize angegeben. Klingeling? ;)

[dazar_t]

ja aber ich verstehe nicht warum SSize danach höchstwahrsch die Länge des Dateinamens enthält
:wall: :wall: :wall: denn ich weiss nicht wieviele zeichen er ließt da er als länge ja Sizeof(SSize) angegeben hat und SSize keinen wert hat.

[Nuclear-Ping]

Und was hab ich paar Beiträge weiter oben geschrieben?

Zitat:

Zitat von Nuclear-Ping

SSize ist ein Byte. Folglich ist SizeOf (SSize) = 1. Also liest er ein Byte. Zusatz: Man kann statt SizeOf (SSize) auch SizeOf (Byte) schreiben. Das wäre das gleiche. Man nutzt deswegen SizeOf, um Plattformkompatibilität zu gewährleisten, da nicht 100% gewährleistet ist, dass auf allen System ein Byte immer 1 groß ist.

In deinem Beispiel oben wird die Größe der zu lesenden Bytes durch die Größe des Arrays vorgegeben. buf: array[1..4096] of byte = length(buf) = 4096.

[dazar_t]

hmmmm und dann schreib ich doch warum dann trotzdem immer der Name herrauskommt obwohl nur ein byte gelesen wird ^^

[Nuclear-Ping]

Die Datei wird wohl so aufgebaut sein:

<Länge des Namens (1 Byte) = X><Name (X Bytes groß)><Länge der Datei (wohl ein Integer = 4 Byte) = Y><Daten der Datei (Y Bytes groß)>

[dazar_t]

DANKE
jetzt ist mir "fast" alles klar.
Aber wenn die dateigröße z.B 104 wäre kleiner als 1 byte würde das ganze nichtmehr funktioniern oder ?

[Nuclear-Ping]

Ein Byte umfasst 0-255. Und damit wird auch nur die Länge des Dateinamens festgehalten. Dateinamen sind in der Regel nicht größer als 255 Zeichen. ;)

Die Dateigröße wird wohl auch nicht in Byte festgehalten werden, sondern als ein Integer, der 4 Bytes groß ist und Zahlen -2147483648 bis 2147483647 aufnehmen kann. Alternativ dazu "Cardinal", wäre das gleiche nur ohne Vorzeichen (also 0-4294967295). Siehe dazu auch die Delphi-Hilfe zum Thema "Integer-Typen".

[dazar_t]

Könnte es nicht zuproblemen kommen wenn der dateiname z.B 14 zeichen lang ist und ebend die 14 dann dort steht. Wenn BlockRead nun ein byte ließt könnte er es nicht auch falsch verstehen und anstatt 14 nur 1 zu lesen , da ein byte ja 0-255 sein kann.

Oder speichert delphi den Integer z.B 14 als ein byte ab in der Compilierten datei?!

[Nuclear-Ping]

Ja, es wird als Binärwert gespeichert, gelesen und intern im Computer auch so gehandhabt. Oder denkst du, wenn der Computer arbeitet intern mit ausgeschriebenen Zahlen?
Schau dir doch die Datei mal in nem Hex-Editor an. Du wirst da nirgends was von "16<Dateiname>4032<Daten>" lesen, sondern höchstens den Dateinamen mit nem "komischen" Zeichen davor und noch mehr "komischen" Zeichen dahinter. ;)

[dazar_t]

DANKE nun habe ich alles verstanden ^^