Ich versteh den Blockreadbefehl nicht :(

[xy124]

Kann mir den jemand erklären (die Delphi hilfe dazu ist d.o.o.f und im internet findet sich auch nix wirklich gutes dazu ), wie das mit Blockread und Blockwrite funktioniert?

Also bei mir sieht es jetzt folgendermaßen aus:

Delphi-Quellcode:

procedure TForm1.Button1Click(Sender: TObject);
var f: file;
    arr: array[0..100] of integer;
    i: Integer;
begin
  AssignFile(f,'mmm.txt'); //öffnen der datei wenn ich das richtig verstehe!

  Reset(f,1);       //das macht die datei wahrscheinlich zum lesen fertig, oder?

  BlockRead(f,arr[0],99);  // was bedeutet der 2. parameter? - da ist ein array und der schreibt die datei in den 0ten speicherplatz
  //aber irgentwie macht der pc doch in dem array weiter?  
  //und der 3. parameter zeigt bis wohin er lesen soll, wenn ich die delphihilfe richtig deute? 
  //die ganze datei soll gelesen werden - wie bekomme ich die länge raus? geht das mit length(f) ?

  CloseFile(f); //das ist klar

  for i := 0 to {ja woher weis ich jetzt wie lang meine Datei ist? } do
    memo1.Lines.Add(inttostr(arr[i]));  
  //so und irgentwie will ich ja auch noch sehen was er für zahlen liest!
end;

also ich hoffe ihr könnt mir helfen!

[Klaus01]

Zitat:

BlockRead(f,arr[0],99); // was bedeutet der 2. parameter? - da ist ein array und der schreibt die datei in den 0ten speicherplatz

1. Paramter das FileHandle, damit sprichst Du die Datei an
2. Parameter eine Buffer in diesem Fall Dein Array
3. Count, die Anzahl der Zeichen die mit einem Blockread Befehl eingelesen werden.

BlockRead(f,arr,101); So würde Dein Array 0..100 gefüllt werden.
Willst Du die ganze Datei lesen, mußt Du Blockread öfter in einer Schleife ausführen.

Noch eine Frage zum Abschluß, warum willst Du die Datei so einlesen?
Willst Du den Befehl Blockread kennenlernen, oder hat es einen tieferen Sinn?
Vielleicht gibt es ja eine bessere Lösung für Dein Problem.

Grüße
Klaus

[himitsu]

in einem Array liegen die einzelnen Elemente im Speicher direkt hintereinander3
also wenn man bei ersten element anfängt was zu lesen/schreiben und weitermacht, dann erwischt man auch die nachfolgenden Elemente.


arr: array[0..100] of integer; ist ein statisches Array, also würde hier
BlockRead(f,arr,100); und BlockRead(f,arr[0],100); auf's Selbe hinausgehn

Allerdings ist bei einem dynamischem array (z.B. arr: array of integer; ) an der Speicherstelle von arr / @arr nur der Zeiger auf den Speicherplatz des Arrays,
somit würde.

arr[0] / @arr[0] zeigen hier aber beim dynamischen array nicht auf den Zeiger zum Array, sondern direkt auf das erste Element und demnach hier auch mit auf die nachfolgenden 99 Elemente.

[xy124]

ich will beides! den blockread-Befehl find ich interessant, weil ich z.B. noch nie mit buffern gearbeitet habe und ich möchte auch ein programm schreiben, was eine delphi unit erstellt, indem es eine Datei mit blockread einliest und dann in der Unit eine prozedur erstellt die das ganze eingelesene dann wieder speichert(blockwrite)! so kann man komfortabel irgentwelche dateien mit compilieren! und bei bedarf extrahieren

also danke für eure Hilfe

der befehl gibt dann also z.B. bei einer Textdatei in dem Array die zahlen für die Zeichen aus, vom anfang bis zum z.B. 101. zeichen!

um zur problematik mit der dateilänge zu kommen - da wäre dann wohl sowas angebracht:

Delphi-Quellcode:

var i: Integer;
    wert: Array[0..1000] of Byte;
    weiter: Boolean;
    f: file;
begin
  i := 0;
  AssignFile(f,'mmm.lol'); //öffnen der datei wenn ich das richtig verstehe!

  Reset(f,1);       //das macht die datei wahrscheinlich zum lesen fertig, oder?

  weiter := true;
  while weiter = true do
    begin
      i := i + 1;
      try
        Blockread(f, wert,i); // da überschreibt er dann immer wieder biss es nicht mehr geht
        memo1.Lines.Add(inttostr(wert[i]));
      except
        weiter := false;
      end;
    end;
  CloseFile(f);
  form1.Caption := inttostr(i)
end;

in meiner datei steht folgendes:

sdm, v hkblsd n.sdn uübse l-.we
w3.menp weö
erö wei wq r

aber im Memo geht es nur bis zeile 11 (eigentlich nur bis 10 aber der macht noch nen Absatz) es sind doch aber vielmehr zeichen!
^^Warum liest er nur 11 bytes?
im Memo steht folgendes:
113
32
114
246
32
119
101
105
32
4



mal ganz abgesehen davon, das er über das dateiende hinaus liest!(diese Fehlermeldung ist mir erstmal egal)

ich hab's noch mal probiert mit der Textdatei in der nur "Hallo" steht

im memo sind nur 2 (nicht 4) Zeilen:
72
97

^^das sieht ja schon nach dem Zeichen code aus! aber warum sind das nur die ersten 2 Zeichen?

[Nuclear-Ping]

Wenn es sich um eine reine Textdatei handelt, ist es besser, entweder die Datei in eine TStringList zu laden oder mit ReadLn zu arbeiten.

[iGoA]

Musst Du vielleicht einfach scrollen? Aktiviere die Scrollbars für Dein Memo.
(klingt vielleicht dümmlich, aber mir ist sowas auch schon passiert)

[Klaus01]

Hallo,

ein Datei komplett einlesen kann man so:

Delphi-Quellcode:

while not eof(f) do
begin
  blockread(f,arr,1000);  //hier liest Du 1000 Zeichen ein
  for i:=low(arr) to high(arr) do
    memo1.lines.add(IntToStr(arr[i]));
end;

Grüße
Klaus

[xy124]

Zitat von Nuclear-Ping:

Wenn es sich um eine reine Textdatei handelt, ist es besser, entweder die Datei in eine TStringList zu laden oder mit ReadLn zu arbeiten.

es ist (leider) nur in dem Beispiel ne Textdatei gewesen!

@Klaus01: so kommt gleich am anfang die Fehlermeldung mit dem Dateiende!

@iGoA hab ich aktiviert - ändert nix!

[em-sigma]

Versuchs mal mit

Blockread(f, wert[i], 1);

[sirius]

Zitat von xy124:

so kann man komfortabel irgentwelche dateien mit compilieren! und bei bedarf extrahieren

Ich bin mir nicht sicher, was du vorhast, aber es klingt komisch.

Du musst dir erstmal überlegen, in welches Format du einlesen willst. Warum nimmst du ein Array of integer? Eine untypisierte Datei wurde (früher) eben genau deswegen verwendet, weil man Werte unterschiedlichen Types abgespeichert hat. Ansonsten hat man schon immer typisierte Dateien (oder Texdateien) verwendet.

btw: Buffer gibt es auch bei TFileStream und der ist allemal besser als eine untypisierte Datei.