Mehrdimensionales, dynamisches Array speichern

[Maik81ftl]

Zitat von himitsu:

Nein, TIniFile ist nicht für viele Daten gedacht, welche sich auch noch oft ändern.

(Begründung siehe anderer Thread)

PS: "HasRegel" schreibt man mit Doppel-S oder mit T.

Deine Begründung in genanten Thread gelesen. und da hab ich mal eine Frage??? Wen zum Teufel kratzen denne Laufzeiten, wenn es auf die nicht in Geringsten ankommt???

wenn ich 'nen Programm schreibe, wo je ns Zählt, denne würde ich auch auf ein anderen Format umsteigen.

Zitat von haentschman:

@himi:

Zitat:

PS: "HasRegel" schreibt man mit Doppel-S oder mit T.

... im Denglisch nicht.

Jopp da hast du recht.

[Dunkelbunt27]

Hallo,

könnte mir vielleicht jemand mal eine Speichern und Laden-Prozedur für meine Variablen schreiben?
So komme ich momentan nicht voran...

Delphi-Quellcode:

type
  TBuchstabe = record
                      Zeichen : char;
                      attribut : byte;
                    end;
buchstabe : array of array of TBuchstabe;

Man kann folgendes verwenden:

Delphi-Quellcode:

SetLength(buchstabe,AnzahlZeilen+1,AnzahlSpalten+1);

for i := 1 to AnzahlZeilen do              // von 1 starten - nicht ändern!
    for n := 1 to AnzahlSpalten do
    begin
      buchstabe[i,n].Zeichen := ' ';
      buchstabe[i,n].attribut := 0;
    end;
  end;

Diesen Datensatz möchte ich möglichst unkompliziert in eine Datei packen UND auch wieder laden können, also aus den gespeicherten Daten der Datei das buchstaben-Array wieder befüllen.

Ich hoffe jemand kann helfen.

FG Dunkelbunt

[Bummi]

Delphi-Quellcode:

type
  TBuchstabe = record
                      Zeichen : char;
                      attribut : byte;
                    end;


TbuchstabenArray = array of array of TBuchstabe;

Procedure SaveTBuchstabenArray(b:TbuchstabenArray;const fn:String);
var
  fs:TFileStream;
  i,x,y:Integer;
begin
  fs:=TFileStream.Create(fn, fmCreate or fmShareDenyWrite);
  try
    x := High(b) + 1;
    y := High(b[0]) + 1;
    fs.Write(x,SizeOf(x));
    fs.Write(y,SizeOf(y));
    for i := low(b) to high(b) do
    fs.Write(b[i][0].Zeichen, y*SizeOf(TBuchstabe));
  finally
    fs.Free;
  end;
end;

Procedure LoadTBuchstabenArray(var b:TbuchstabenArray;const fn:String);
var
  fs:TFileStream;
  i,x,y:Integer;
begin
  fs:=TFileStream.Create(fn, fmOpenRead);
  try
    fs.Read(x,SizeOf(x));
    fs.Read(y,SizeOf(y));
    SetLength(b,x,y);
    for i := low(b) to high(b) do
    fs.Read(b[i][0].Zeichen, y*SizeOf(TBuchstabe));
  finally
    fs.Free;
  end;
end;

[Dunkelbunt27]

Ich stand ja richtig auf der Leitung...
ich hab es etwas abgeändert, nur zur 'Übersichtlichkeit', da ich mich mit sprechenden Bezeichnungen besser zurecht finde.

Delphi-Quellcode:

type
  TBuchstabe      = record
                      Zeichen  : char;
                      attribut : byte;
                    end;
var
  buchstabe       : array of array of TBuchstabe;

Procedure Speichern(const Dateiname:String);
var
  Datei:TFileStream;
  i,x,y:Integer;
begin
  Datei:=TFileStream.Create(Dateiname, fmCreate or fmShareDenyWrite);
  try
    x := High(buchstabe) + 1;
    y := High(buchstabe[0]) + 1;
    Datei.Write(x,SizeOf(x));
    Datei.Write(y,SizeOf(y));
    for i := low(buchstabe) to high(buchstabe) do
    Datei.Write(buchstabe[i][0].Zeichen, y*SizeOf(TBuchstabe));
  finally
    Datei.Free;
  end;
end;

Procedure Laden(const Dateiname:String);
var
  Datei:    TFileStream;
  i,x,y: Integer;
begin
  Datei:=TFileStream.Create(Dateiname, fmOpenRead);
  try
    Datei.Read(x,SizeOf(x));
    Datei.Read(y,SizeOf(y));
    SetLength(buchstabe,x,y);
    for i := low(buchstabe) to high(buchstabe) do
    Datei.Read(buchstabe[i][0].Zeichen, y*SizeOf(TBuchstabe));
  finally
    Datei.Free;
  end;
end;

Vielen Dank für eure Arbeit!
FG Dunkelbunt

[DeddyH]

Wenn das Array leer ist, bekommst Du Probleme beim Speichern, da Du in der ersten Dimension auf das erste Element zugreifst, ohne es auf Existenz zu prüfen. Beim Lesen hast Du das selbe Problem bei einer leeren Datei. Und statt

Zitat:

x := High(buchstabe) + 1;

würde ich eher
x := Length(buchstabe); schreiben.

[himitsu]

Zitat von DeddyH:

Wenn das Array leer ist, bekommst Du Probleme beim Speichern, da Du in der ersten Dimension auf das erste Element zugreifst, ohne es auf Existenz zu prüfen. Beim Lesen hast Du das selbe Problem bei einer leeren Datei. Und statt

Zitat:

x := High(buchstabe) + 1;

würde ich eher
x := Length(buchstabe); schreiben.

Das macht eigentlich keinen unterschied, da es equivalent ist, denn die Funktion High ist so definiert

Delphi-Quellcode:

function High(const a: TMyArray): integer;
begin
  Result := Length(a) - 1;
end;

Bei statischen Arrays wird es ebenso im Compiler ausgerechnet und dann direkt verwendet.


Aber natürlichst speicherst/liest du immer nur den ersten Wert aller SubArrays (egal ob sie existieren oder nicht) und alle weiteren Daten der Subarrays werden ignoriert,
also für x = 1 bis Ende (buchstabe[i][x] )

[DeddyH]

Dass das bei dynamischen Arrays keinen Unterschied macht, weiß ich auch. Aber erstens ist das so verständlicher, da es ja um die Länge geht und zweitens sollte man sich das gleich richtig angewöhnen, sonst bekommt man bei statischen Arrays, die nicht 0-indiziert sind, später Probleme.

[Dunkelbunt27]

Zitat:

Aber erstens ist das so verständlicher, da es ja um die Länge geht und zweitens sollte man sich das gleich richtig angewöhnen, sonst bekommt man bei statischen Arrays, die nicht 0-indiziert sind, später Probleme.

Das ist ein guter Einwand, ich persönlich finde es so verständlicher.

Wo wir gerade beim Thema sind, könnte mir jemand mal diese Zeile erklären:

Zitat:

Datei.Read(buchstabe[i][0].Zeichen, y*SizeOf(TBuchstabe));

TBuchstabe ist ja ein Typ (Record aus Zeichen, Attribut) was liefert denn SizeOf(TBuchstabe) zurück?
X ist die Länge in beide dimensionen, oder wird automatisch nur die x Dimension genommen?
Y ist dann die Länge für die Y Dimension, wenn X=0, richtig?

Ich versteh nicht ganz wo die Attribute und Zeichen gespeichert werden.

FG Dunkelbunt

[Bummi]

Der Record wird als ganzes gespeichert, dies geht bei allen Recordstrukturen die nur aus Elementen einer "fixen Größe" bestehen als z.B. String[33] statt String beinhalten.
SizeOf liefert bei Deiner Definition 4 Byte bei der Definition

Delphi-Quellcode:

  TBuchstabe = packed record
                      Zeichen : char;
                      attribut : byte;
                    end;

3 Byte ....aehaem, ab 2009 da dort Char=2Byte