Listen und wie man sie nutzt

[Obelisk2k5]

Nachdem ich hier schonmal gute Hilfe zum Thema Datenverwaltung erhalten habe,
gehe ich gleich zu meinem nächsten Problem über, bei dem ich Hilfestellung bräuchte:

Ich habe ein Programm geschrieben, dass zur Laufzeit Records in einem Array speichert und damit arbeitet.

Nun möchte ich dieses Array durch Listen ersetzen.

Ich habe schon einen Ansatz parat, nur weiß ich nicht, ob das so richtig ist und was geändert werden muss.
Daher schreibe ich den relevanten Programmcode hier auf und stelle programmbezogene Fragen als Kommentare im Code.

Zunächst einmal das Record TDeveloper samt Komponenten,
welches nicht verändert werden sollte.
Es ist in eine andere Unit ausgelagert:

Delphi-Quellcode:

TName = String[20];

TPerson = record
  sureName : TName;
  lastName : TName;
end;

TDeveloperID = Integer;

TDeveloper = record
  developerID : TDeveloperID;
  developerPerson : TPerson;
  developerDescription : TDescription;
end;

Nun der interessante Teil:

Delphi-Quellcode:

type
  TListe = ^TElement;
  TElement = record
               content : TDeveloper;
               Next : TListe;
             end;

// Ist dies so richtig? Habe mich etwas eingelesen, und da wurde ein Record mit einem Next-Teil 
// benutzt. Da ich das eigentliche Record nicht verändern will, habe ich es so gelöst.
var
  First : TListe = nil;
  Last : TListe = nil;
  Allocations : integer; 
// Wird benutzt, um im Finalizationteil zu prüfen, ob alle Listenelemente wieder freigegeben wurden


function NewElement(person: TPerson; description: TDescription) : boolean;
var
  TempElement,
  RunPointer : TListe;
  I: byte;
  Temp_ID: Integer;
begin
  if developersCount < DEVELOPER_MAX then
  begin
    First := nil;

// ---- Temporäre ID -----------------------------------------------------------

    Temp_ID := DEVELOPER_ID_MIN + DEVELOPER_MIN;

// ---- Wenn es schon andere Developer gibt, wird die Temporäre ID inkrementiert,
// ---- bis sie einen Wert hat, der noch nicht als Developer ID vergeben ist ---

  if developersCount > 0 then
    begin
    for I := DEVELOPER_MIN to DEVELOPER_MAX do
    Runpointer := first;
      While RunPointer <> nil do
        begin
        if Runpointer^.content.developerID = Temp_ID then
          inc(Temp_ID);
          Runpointer := Runpointer^.Next;
        end;
    end;
//--------------------------------------------------------------------------------

    new (TempElement);
    TempElement.content.developerID := Temp_ID;
    TempElement.content.developerPerson := person;
    TempElement.content.developerDescription := description;
    TempElement.Next := nil;
    if first = nil then
    begin
      First := TempElement;
      Last := First;
    end
      else
      begin
        Last^.Next := TempElement;
        Last := Last^.Next;
      end;
    NewElement := true;
  end
    else NewElement := false;
end;

// Noch etwas: In dem Berspiel, das ich gelesen habe, lieferte die Funktion NewElement einen 
// Rückgabewert vom Typ TListe und am Ende wurde NewElement := First; gesetzt.
// Nur brauche ich eine Funktion, die bei Erfolg true liefert.
// Wieso wird NewElement auf First gesetzt und wie löse ich das am besten?

[idefix2]

Es gibt doch in delphi die fertige Klasse TList, die alles beinhaltet, was Du für die Verwaltung von Listen brauchst.

Von der brauchst Du nur mehr Deine spezifische Klasse ableiten.

[Obelisk2k5]

In den Beispielen, die ich gelesen habe, wird TListe so als typ deklariert:

Code:

type
  TListe = ^TElement;
  TElement = record
               Value : Integer;
               Next : TListe;
             end;

var
  First : TListe; {Einstiegszeiger}

Da ich das Endergebnis einreichen muss, werde ich mich wohl daran halten müssen.

[Hansa]

Ist die Fragestellung so vorgegeben ? Es geht mir da um das Hütchen :^. Also wären das dann verkettete Listen etc. Dann geht es mehr um die Theorie. In der Praxis stellt Delphi jedenfalls einiges an fertigen Methoden zur Verfügung. TList, wie bereits gesagt und TObjectList. Und dafür braucht man kein ^. Oder etwa doch ?

[idefix2]

Es kommt darauf an, was Du willst:

Willst Du üben, wie das Programmieren von Listenstrukturen aussieht, dann wirst Du irgend so eine Pointer Struktur brauchen, mit der Du Listen nachbildest. Das kann je nach Bedarf eine einfach oder doppelt verkettete Liste oder ein B-Baum oder was auch immer sein.

Wenn Du einfach nur eine Liste brauchst, dann verwende TList oder TObjectlist, da hast Du nichts mehr mir "^" zu tun, die ganze Zeigerlogik ist in der Klasse schon fertig und gekapselt. Schau Dir dazu in der Delphi Hilfe die beiden Klassen an.

[Obelisk2k5]

Zitat von idefix2:

Es kommt darauf an, was Du willst:

Willst Du üben, wie das Programmieren von Listenstrukturen aussieht, dann wirst Du irgend so eine Pointer Struktur brauchen, mit der Du Listen nachbildest. Das kann je nach Bedarf eine einfach oder doppelt verkettete Liste oder ein B-Baum oder was auch immer sein.

Wenn Du einfach nur eine Liste brauchst, dann verwende TList oder TObjectlist, da hast Du nichts mehr mir "^" zu tun, die ganze Zeigerlogik ist in der Klasse schon fertig und gekapselt. Schau Dir dazu in der Delphi Hilfe die beiden Klassen an.

Ich möchte ersteres, undzwar eine einfach verkettete Liste.