Dynamische Arrays "zu Fuß"

[Luckie]

Dynamische Arrays sind ja erst ab D4 und höher bekannt. Aber es gibt ja schon unter D3 Stringliste, was ja im Endeffekt auch nur ein dynmaisches Array of String ist. Da ich damit leibäugle mir D3 Professional ("Delphi for Kids" läßt grüßen) zu kaufen und ich des öfteren doch auf dynamische Arrays angewiesen bin, wollte ich mal fragen, wie man dynamische Arrays zu Fuß, also selber erstellt.

[Chewie]

Dynamische Arrays funktionieren ja so, dass bei einem Aufruf von SetLength() soviel Speicher alloziert wird, wie das Array benötigt (also Länge des Array * Elementgröße). Der Zugriff auf ein Speicherelement erfolgt mit der Formel Startadressse + Index * Elementgröße. Bei jedem Aufruf von SetLength wird nun das Array an einen anderen Speicherplatz kopiert und der alte Speicher freigegeben. Pack das ganze in eine schöne Klasse und das sollte es gewesen sein.
OK, du musst für jeden Datentyp eine eigene Implementierung machen, aber das dürfte weitgehend mit C&P zu lösen sein.

So mal ein Beispiel, wie der Umgang mit diesem Objekt wäre. Die Daten selbst wären über einen Pointer abgespeichert, außerdem muss die Anzahl der Einträge gespeichert werden.

Delphi-Quellcode:

//die Klasse heißt TDynArray
myArray := TDynArray.Create(1);  //Array mit der Länge erzeugen, im Konstruktor Aufruf von SetLength
myArray[0] := myVar;  //myVar an Startposition + 0 schreiben
myArray.SetLength(2);  //jetzt werden die ganzen Daten des Array an eine neue Speicherstelle kopiert
myArray.Free;

SetLength würde folgendes tun:
- NeueLänge * Elementgröße Bytes Speicher allozieren
- AlteLänge * Elementgröße Bytes ausgehend von DataPointer in neuen Speicher kopieren
- DataPointer mit alter Länge freigeben
- DataPointer bekommt die Adresse des neuen Speicherbereichs
- Fallunterscheidung: bei Länge 0 kein Kopieren nötig.

Der Zugriff auf ein Element:
- Die Adresse Index * Elementgröße + Datapointer dereferenzieren und in entsprechenden Typ casten

So könnte man das lösen.

[Luckie]

Ich habe mal versucht das irgendwie umzusetzten, nach einen Tipp von tommie-lie, der hat sich aber leider unter die Dusche verdrückt.

Bitte nicht lachen, mit Zeigern habe ich es nicht so.

Delphi-Quellcode:

type
  PString = ^String;

var
  StringArray: PString;

implementation

{$R *.dfm}

procedure TForm1.Button1Click(Sender: TObject);
begin
  GetMem(StringArray, sizeof(StringArray)+1*sizeof(PString));
  PString(StringArray)^ := Edit1.Text;
end;

Ich bekomme allerdings eine AccessViolation.

[Jens Schumann]

Hallo Luckie,
möchtest Du wirklich dyn. Array verwenden oder machst Du das nur aus interesse ?
TList liefert eigentlich schon alles was Du brauchst. Wenn Du auf max. Geschwindigkeit
aus bist dann versuche es mit einer verketteten Liste (beispiele finden sich überall).

Ich bin noch nie in eine Situation gekommen die ich nur mit einem dyn. Array lösen konnte.
Deshalb behaupte ich:

!!! Dyn. Array braucht keiner!!!

Ich glaube die dyn. Array's wurden nur für Basic-Programmierer in Delpih aufgenommen.

[Hansa]

Zitat von Jens Schumann:

Ich bin noch nie in eine Situation gekommen die ich nur mit einem dyn. Array lösen konnte.
Deshalb behaupte ich:

!!! Dyn. Array braucht keiner!!!

Ich glaube die dyn. Array's wurden nur für Basic-Programmierer in Delpih aufgenommen.

Dem ist voll zuzustimmen ! Ich zumindest verwende ein starres Array, sofern die Anzahl der Elemente vorher klar ist, oder direkt verkettete Listen. Dynamische Arrays hängen irgendwie dazwischen. Aber: ist bspw. ein StringGrid nicht auch ein dyn. Array ?

[Luckie]

Nun ja, interesse und weil D3 keine dynamischen Arrays kennt.

Mit TList habe ich noch nie gearbeitet. Kennt das D3 denn? Und wie ginge es damit?

[Jens Schumann]

Hallo Luckie

Zitat von Luckie:

Mit TList habe ich noch nie gearbeitet. Kennt das D3 denn?

TList gibt es schon seit D1.

TList ist in der Delphi-Hilfe bestens dokumentiert.

[Chewie]

Ich würds gar nicht so kompliziert machen und auf einen Typ ausrichte.

Hab hier mal was kleines geschrieben, so wie ichs mir vorstelle:

Delphi-Quellcode:

unit DynArray;

interface
  TDynArray = class
  private
    FDataPointer: Pointer;
    FElementSize: Integer;
    FDataSize: Integer;
    function GetValue(Index: Integer): Integer;
    procedure SetValue(Index: Integer; const Value: Integer);
    procedure CopyData(Destination: Pointer; Size: Integer);
  public
    constructor Create(InitialLength: Integer);
    destructor Destroy; override;
    property Value[Index: Integer]: Integer read GetValue write SetValue;
    procedure SetLength(NewLength: Integer);
  end;

const
  ElementSize = sizeof(Integer);

implementation

{ TDynArray }

procedure TDynArray.CopyData(Destination: Pointer; Size: Integer);
begin
  CopyMemory(Destination, FDataPointer, Size);
end;

constructor TDynArray.Create(InitialLength: Integer);
begin
  FElementSize := ElementSize;
  FDataPointer := nil;
  FDataSize := 0;
  SetLength(InitialLength);
end;

destructor TDynArray.Destroy;
begin
  SetLength(0);
end;

function TDynArray.GetValue(Index: Integer): Integer;
begin
  if Index > Pred(FDataSize) then
    //irgendeine Exception oder sowas auslösen
  Result := Integer(Pointer(Integer(FDataPointer) + Index * FElementSize)^);
end;

procedure TDynArray.SetLength(NewLength: Integer);
var
  NewData: Pointer;
begin
  if NewLength <> 0 then
    FreeMem(FDataPointer, FDataSize * FElementSize);
  GetMem(NewData, NewLength * FElementSize);
  if FDataSize <> 0 then
    CopyData(NewData, FDataSize * FElementSize);
  FreeMem(FDataPointer, FDataSize * FElementSize);
  FDataPointer := NewData;
end;

procedure TDynArray.SetValue(Index: Integer; const Value: Integer);
begin
  if Index > Pred(FDataSize) then
    //irgendeine Exception oder sowas auslösen
  Integer(Pointer(Integer(FDataPointer) + Index * FElementSize)^) := Value;
end;

end.

[Luckie]

So, nach der Anregung von Herrn Schumann die Lösung mit TList:

Delphi-Quellcode:

type
  StringArray = record
    MyString: String;
  end;
  PStringArray = ^StringArray;

implementation

{$R *.dfm}

procedure TForm1.Button1Click(Sender: TObject);
var
  MyList: Tlist;
  sa: PStringArray;
  Loop: Integer;
begin
  MyList := TList.Create;
  try
    New(sa);
    sa.MyString := 'Egon';
    MyList.Add(sa);
    New(sa);
    sa.MyString := 'Klaus';
    MyList.Add(sa);
    New(sa);
    sa.MyString := 'Michaela';
    MyList.Add(sa);
    for Loop := 0 to myList.Count-1 do
    begin
      sa := MyList.Items[Loop];
      Listbox1.Items.Add(sa.MyString);
    end;
    for Loop := 0 to MyList.Count-1 do
    begin
      sa := MyList.Items[Loop];
      Dispose(sa);
    end;
  finally
    FreeAndNil(MyList);
  end;
end;

Eigentlich auch so in der Hilfe zu finden.

Zu beahcten ist nur, dass man vor dem Hinzufügen, neuen Speicher reserviert (New) für den Record und nach Gebrauch selbigen wieder frei gibt (Dispose). Ist eventuell etwas umständlicher, dafür ist man mit dem Zeiger auf den Record aber felxibeler, man kann mehr Speichern und muss nicht auf mehrdimensionale Arrays zurückgreifen.

[Chewie]

Zitat:

Ist eventuell etwas umständlicher, dafür ist man mit dem Zeiger auf den Record aber felxibeler

Wieso flexibler? Man kann auch ein Array of Pointer oder sogar ein Array of PStringArray nehmen. Dann spart man sich sogar das Typisieren.