Doppelt verkettete Liste als generischer Typ

[Schorschi5566]

Hallo DP,

ich habe eine doppelt verkettete Liste als einfache Basis-Klasse TChainList:

Delphi-Quellcode:

type
  TChainList = class(TPersistent)
  private
    FDeleting: Boolean;
    FEol: Boolean;
    FPredecessor: TChainList;
    FSuccessor: TChainList;
    function GetEol: Boolean;
    procedure SetDeleting(const Value: Boolean);
    property Deleting: Boolean read FDeleting write SetDeleting;
  public
    destructor Destroy; override;
    procedure Add(Item: TChainList); virtual;
    function Delete: TChainList;
    function Last: TChainList;
    function First: TChainList;
    function Next: TChainList;
    function Previous: TChainList;
    property Eol: Boolean read GetEol;
  end;

Verwendet wird sie dann beispielsweise so:

Delphi-Quellcode:

type
  TTestClass = class(TChainList)
  private
    FData: string;
  public
    function Add(Text: string): TTestClass; overload;
    property Data: string read FData write FData;
  end;

.
.
.

procedure TForm1.Test;
var
  Chain: TTestClass;
begin
  Chain := TTestClass.Create;
  try
    Chain.Data := 'Test1';
    Chain.Add('Test2');
    Chain.Add('Test3');
    Chain.Add('Test4');
    Chain := Chain.First as TTestClass; // blöder Cast
    while not Chain.Eol do
    begin
      // do something
      Chain := Chain.Next as TTestClass; // blöder Cast
    end;
  finally
    Chain.Free;
  end;
end;

Ich möchte das Ganze ohne die Casts haben und dachte an eine generische Liste. Allerdings meckert er immer, dass T einen public parameterlosen Konstruktur braucht. Aber das tut er auch, wenn ich der abgeleiteten Klasse einen gebe.

Probiert habe ich die Basisklasse auf TChainList<T: class, constructor> = class umzuschreiben.

Eine Deklaration mit

Delphi-Quellcode:

type
  TTestClass = class(TChainList<TTestClass>) // wohl etwas zu gewagter Rückbezug auf sich selbst...
  private
    FData: string;
  public
    function Add(Text: string): TTestClass; overload;
    property Data: string read FData write FData;
  end;

geht dann aber mit obigem Compilerfehler schief.


Geht das überhaupt? Oder geht es wenigstens auf andere Art?



Viele Grüße,
Uwe

[mkinzler]

Du wirfst hier Einträge und Listen durcheinnander.
Der Vorgänger/Nachfolger sind keine Listen sondern Elemente

[Schorschi5566]

Hallo Mkinzler,

mit Einträgen und Listen ist's ja kein Problem. :stupid:
Das soll schon so sein, dass einem Eintrag auf diese Weise seine eigene Liste bekannt wird.


Viele Grüße,
Uwe

[DeddyH]

Und was wird z.B. hier zurückgegeben?

Zitat:

Delphi-Quellcode:

function Last: TChainList;

Ich hätte ja auch gedacht, dass es da einen Typ TChainItem oder so gibt, der im Grunde lediglich ein Pointer ist.

[Schorschi5566]

Hallo DeddyH,

na es wird das letzte Element der verketteten Liste zurückgegeben.

Delphi-Quellcode:

function TChainList.Last: TChainList;
begin
  Result := Self;
  if Self <> nil then
  begin
    while Result.FSuccessor <> nil do
      Result := Result.FSuccessor;
    FEol := False;
  end;
end;

Der Witz ist ja gerade, dass man nicht Liste und Elemente verwalten muss sondern nur die Elemente. Finde ich eigentlich ganz elegant, wenn die Casts nicht wären.

[mkinzler]

Bei einer generischen Liste entfällt der Cast.

[DeddyH]

Diese Vorgehensweise ist mir neu. Ich hätte da eher einen Elementtyp deklariert und die Listenklasse, die einem die Verwaltung und Navigation abnimmt.

[mkinzler]

Zitat:

Zitat von DeddyH (Beitrag 1274211)

Diese Vorgehensweise ist mir neu. Ich hätte da eher einen Elementtyp deklariert und die Listenklasse, die einem die Verwaltung und Navigation abnimmt.

Ich auch.

[Schorschi5566]

Zitat:

Zitat von mkinzler (Beitrag 1274210)

Bei einer generischen Liste entfällt der Cast.

Wenn Du mir jetzt noch sagst, wie man das deklariert, wäre meine Frage beantwortet. 8-)

Es geht mir nicht um den klassischen Ansatz mit Elementen und einer Liste, die die Elemente verwaltet. Das ist über TList<T> oder Ähnliches keine Sache.

Ich möchte den Elementen über ihre Basisklasse gleich die Listenverwaltung mitgeben. Das funktioniert ja auch. Lediglich die Casts stören mich bei diesem Ansatz und meine Frage war ob jemand weiß ob man das mit Generics lösen könnte und wie.

[mkinzler]

https://delphihaven.wordpress.com/category/generics/

[CarlAshnikov]

Ich glaube du vermischst hier Daten und die Listen-Items. Falls ich dich richtig verstehe würde es meiner Meinung nach so aussehen:

Delphi-Quellcode:

type
  TChainList<T> = class(TPersistent)
  private
    FData:T;
    FDeleting: Boolean;
    FEol: Boolean;
    FPredecessor: TChainList;
    FSuccessor: TChainList;
    function GetEol: Boolean;
    procedure SetDeleting(const Value: Boolean);
    property Deleting: Boolean read FDeleting write SetDeleting;
  public
    destructor Destroy; override;
    procedure Add(Item: T);
    function Delete: TChainList;
    function Last: TChainList;
    function First: TChainList;
    function Next: TChainList;
    function Previous: TChainList;
    property Eol: Boolean read GetEol;
    property Data: T read FData write FData;
  end; 

  TTestClass = class(TChainList<string>)

  end;

[DeddyH]

Was hältst Du von diesem Ansatz?

Delphi-Quellcode:

type
  TChainElement<T> = class
  private
    FData: T;
    FNext: TChainElement<T>;
    FPrior: TChainElement<T>;
  public
    property Data: T read FData write FData;
    property Next: TChainElement<T> read FNext write FNext;
    property Prior: TChainElement<T> read FPrior write FPrior;
  end;

  TChain<T> = class
  private
    FFirstElement: TChainElement<T>;
    FLastElement: TChainElement<T>;
    FCurrentElement: TChainElement<T>;
    function GetNext: TChainElement<T>;
    function GetPrior: TChainElement<T>;
    function GetBOF: Boolean;
    function GetEOF: Boolean;
    function GetFirst: TChainElement<T>;
    function GetLast: TChainElement<T>;
  public
    function Add: TChainElement<T>;
    procedure Delete(Item: TChainElement<T>);
    procedure Clear;
    property BOF: Boolean read GetBOF;
    property EOF: Boolean read GetEOF;
    property First: TChainElement<T> read GetFirst;
    property Last: TChainElement<T> read GetLast;
    property Next: TChainElement<T> read GetNext;
    property Prior: TChainElement<T> read GetPrior;
  end;

Und wenn Du unbedingt willst, kannst Du die Listenklasse weglassen und alles in der Element-Klasse implementieren.

[edit] Na toll, da tippe ich mir einen ab und andere sind wieder schneller. [/edit]

[Schorschi5566]

Zitat:

Zitat von mkinzler (Beitrag 1274216)

https://delphihaven.wordpress.com/category/generics/

Vielen Dank. Das hilft mir weiter.


Grüße,
Uwe

[Stevie]

In Spring4D gibt's auch eine Implementierung.