Wie funktioniert BlockRead/Write?

[PAX]

Ihr müsst mir mal erklären, was bei der Anwendung von BlockRead + BlockWrite genau passiert,
unter dem Gesichtspunkt der Blockgröße.
Ich beschäftige mich nun frisch mit diesen Prozeduren und hab nähmlich keine genaue Vostellung davon, da alles bei Versuchen in Widersprüchen endete.

BlockWrite(Datei,Zeichenkette[1],Blockgroesse);
BlockWrite(Datei,Zeichenkette[2],Blockgroesse);
BlockWrite(Datei,Zeichenkette[3],Blockgroesse);

Gehe ich recht in der Annahme, dass wenn ich Blockgröße auf 1 setze, immer jeder Block eine bestimmte Größe hat (welche ist es) und somit die Zeichenkette abgeschnitten wird, wenn sie diesen Wert überschreitet?
Wenn dies der Fall wäre, müsste ich mich auf eine Blockgröße festsetzen, da die länge der Zeichenketten unterschiedlich ist und alle in die selbige Datei geschrieben werden. Sagen wir als Beispiel mal, Zeichenkette[1] = 3 Bytes, Zeichenkette[2] = 7 Bytes, Zeichenkette[3] = 1 Byte und Blockgröße = 10 Bytes. Nun dürfte ich doch die Strings originalgetreu auch wieder einlesen können, wenn ich die richtige Blockgröße angeben?
Und was hat es nun bei Reset/Rewrite mit einer eventuellen Blockgrößenangabe auf sich? Was ist, wenn ich die weglasse, bzw. angebe?
Und mir ist noch etwas aufgefallen. Unter gewissen Umständen funktionierte ja fehlerfreies Schreiben+Einlesen (genau das ist ja für mich das Rätsel, da ich bei beiden Versuchen keinen Unterschied erkenne). Jedenfalls, bei dem funktionierenden Test brach das Programm durch eine Zugriffsverletzung ab, wenn ich dem Stringbezeichner, welcher zum Wiedereinlesen verwendet wurde, vorher noch nie einen Wert zugewiesen habe. Also wenn ich dann einfach nur vorher der Zeichenkette := ' ' , funktionierte alles einwandfrei. (?!)

Also nochmal zusammengefasst: Ich möchte mehrere Strings unterschiedlicher länge in eine untypisierte Datei schreiben und wieder so, wie sie vorher waren, einlesen können.
Die Blockgröße ist nun das größte Rätsel für mich.

Ich hoffe ihr versteht, was mein Problem ist, und wo der Gedakengang falsch war, weil mir vielleicht eine Information fehlt oder ich die Sache komplett missverstanden habe.
In diesem Sinne,
machts mal ganz gut!

PAX

[edit=Luckie] Mfg, Luckie[/edit]

[fiasko]

Hallo,

ich verstehe nicht ganz was du da geschrieben hast.. soll Zeichenkette ein String sein oder ein array of string?

Das BlockWrite schreibt einfach Blockgroesse Bytes von der Adresse der Variable die du ihm gibst. Dabei ist zu beachten das die Variable selbstständig referenziert wird - wenn du also einen Pointer auf deine Daten hast mußt du sie vorher dereferenzieren.

Beispiele:

Delphi-Quellcode:

var
 h: String;
 g: array of String;

BlockWrite(Datei, "Muhh", 4);  // Schreibt Muhh in die Datei

BlockWrite(Datei, h[1], length(h));  // Schreibt den Inhalt von h in die Datei
BlockWrite(Datei, PChar(h)^, length(h));  // Schreibt den Inhalt von h in die Datei

BlockWrite(Datei, g[1][1], length(g[1])); // Schreibt den Inhalt des 1. Strings des Arrays in die Datei
BlockWrite(Datei, g[2][1], length(g[2])); // Schreibt den Inhalt des 2. Strings des Arrays in die Datei

Hoffe ich hab mich halbwegs verständlich ausgedrückt...

[edit]
Wo Variable g stehen sollte auch wirklich g hingeschrieben...
[/edit]

[PAX]

Ok, das ist ja schonmal sehr informativ, was ich da höre :) . Also dankschön erstmal. Ja, mit Zeichenkette meinte ich nur einzelne Strings (aber kein Array). h ist nun das Array in deinem Beispiel. Was für mich jetzt wieder noch neu ist, ist die zweite Indexangabe des Arrays im Beispiel (h[1][2]). Was hat die 2. Indexangabe für eine Bedeutung? Und bei der Blockgröße, wenn ich dann immer dafür die Länge der aktuell reinzuschreibenden Variablen angebe, werden dann die einzelnen Blöcke unterschiedlich groß in der Datei? Wie lese ich das dann wieder vernünftig ein, wenn ich nicht weiß, wie groß die dann immer sind.
Aus dem ersten Beispiel mit 'Muuh' leite ich ab, dass die Blockgröße wirklich in Byte angegeben wird (hier: 4). Wenn ich bei dieser Methode nun 3 angegeben hätte, würde dann zum Schluss in der Datei nur 'Muu' stehen?
Und dieses PChar(), zerlegt es den String dann einfach nur? Und schreibt er die Teile dann alle in Extrablöcke? Ich weiß dann aber beim Einlesen nicht, wieviele Blöcke zum selbigen String gehörten. UNd ich seh gerade, da is ja noch ein Zeiger, damit kann ich zur Zeit auch noch nicht mit umgehen. Was spielt sich dort abß
Ich danke dir


PAX

[fiasko]

Zitat:

Zitat von PAX

h ist nun das Array in deinem Beispiel.

Ne, das ist g - ist jetzt oben gefixt. Du kannst einen String aber als dynamisches Array verstehen, wobei das erste Zeichen bei h[1] steht.

Zitat:

Zitat von PAX

Und bei der Blockgröße, wenn ich dann immer dafür die Länge der aktuell reinzuschreibenden Variablen angebe, werden dann die einzelnen Blöcke unterschiedlich groß in der Datei?

Also es gibt keine "Blöcke" in Dateien wie du dir das jetzt vielleichst vorstellst. Er schreibt einfach die angegebene Anzahl der Bytes des Inhaltes der Variable in die Datei.

Zitat:

Zitat von PAX

Wie lese ich das dann wieder vernünftig ein, wenn ich nicht weiß, wie groß die dann immer sind.

Da gibt es mehrere Möglichkeiten. Du könntest vor jedem String die Länge speichern, oder du führst ein Trennzeichen ein und ließt immer solange bis das erreicht wird. Oder du legst fest das die Einträge immer gleich groß sind. Das hängt jetzt davon ab was du speichern willst. Wenn es einfach nur ein paar Strings sind bietet sich vielleicht auch eher ne einfach Textdatei an, wo du die Strings zeilenweise reinspeicherst.

Zitat:

Zitat von PAX

Aus dem ersten Beispiel mit 'Muuh' leite ich ab, dass die Blockgröße wirklich in Byte angegeben wird (hier: 4). Wenn ich bei dieser Methode nun 3 angegeben hätte, würde dann zum Schluss in der Datei nur 'Muu' stehen?

Ja, es würde dann "Muh" ;-) drinne stehen.

Zitat:

Zitat von PAX

Und dieses PChar(), zerlegt es den String dann einfach nur? Und schreibt er die Teile dann alle in Extrablöcke?

Das PChar (~ Pointer of Char) gibt den Zeiger auf das erste Zeichen im String zurück. Dieses kleine^ dahinter derefenziert das wieder. Das ist der gleiche Effekt wie mit dem h[1], es gilt also:

Delphi-Quellcode:

h:='Muhh';

h[1] = 'M';
PChar(h)^ = 'M';

// bzw. die Adressen sind auch gleich:

@h[1] = PChar(h);

[PAX]

Wenn ich eine größere Blockgröße angebe, als der String lang ist, dann wird sicherlich der Rest nicht mit ' ' aufgefüllt. Das bedeutet also, ich müsste vorher manipulativ den String auf die gewünschte Größe bringen?

[dizzy]

Den müsstest du selber auffüllen - ja. Sonst wird entweder Müll dahinter geschrieben, oder im schlimmeren Fall gibts eine AV - währscheinlicher ist aber der Müll :).

Wenn du aber weisst wie lang die Strings jeweils werden, böte es sich an mit ShortString zu arbeiten, oder mit einem array[Zeichenanzahl: Integer] of Char. Das Hantieren damit ist erstmal gleich, aber du kannst diese Typen - da sie eine feste Länge haben mit 0 initialisieren bevor du etwas rein schreibst. Dazu schau dir mal die Prozedur FillChar an.

Gruss,
Fabian

[fiasko]

...oder du nimmst einfach Strings und setzt die auf eine feste Länge mit setlength. Alle Elemente 0'en kannst du mit FillChar.

[PAX]

Ich danke euch! :)
Unter welchen Voraussetzungen kann es passieren, dass die Variable, in der ich etwas einlese, "keinen verfügbaren Wert" enthält?
Ich hab jetzt die Variante mit dem Trennzeichen ausgewählt. Ich schreibe die entsprechenden Sachen in die Datei und filtere beim Einlesen die einzelnen Strings durch das Trennzeichen heraus. Das ganze Programm bricht immer mit einer Zugriffsverletzung ab, sobald verglichen wird, ob das eingelesene Zeichen dem Trennzeichen entspricht (bei Vergleich nach <> kein Abbruch) (If s = Trennz Then...). Ich hab dann mal überprüft, welchen Wert die Einlesevariable zu dem Zeitpunkt hat, und zwar gar keinen. Woran liegts nun?

[fiasko]

Bevor wir anfangen zu raten, poste doch mal deinen Code :mrgreen:

[PAX]

Delphi-Quellcode:

var EinleseString: String;
    zweiteListBox: boolean;
begin
  EinleseString:=' ';     //wenn der Einlesestring vorher noch einen Wert zugewiesen bekommen hat, 
  Vokabel:='';          //dann bricht das Prog beim Einlesen auch ab
  zweiteListBox := false;
  OpenDialog1.Execute;
  AssignFile(Datei,OpenDialog1.FileName);    
  Reset(Datei);        

    While not EOF(Datei) do begin
      BlockRead(Datei,EinleseString,1);

      If EinleseString <> '¿' Then begin
        Insert(EinleseString,Vokabel,Length(Vokabel))
      end;

      If EinleseString = '¿' Then begin          //mit genau dieser Zeile kommt er nicht klar
        If zweiteListBox = true Then begin
          ListBox2.Items.Add(Vokabel);
          Vokabel:='';
          zweiteListBox := false;
        end else begin
          ListBox1.Items.Add(Vokabel);
          Vokabel:='';
          zweiteListBox := true
        end;
      end;
    end;

  CloseFile(Datei);
end;