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.