Eine Frage zu Generics in generischen Listen

[Catweasel77]

Zitat:

Die Eigenschaft Items liefert doch ein TObject zurück (geerbt von TObjectList )
Die Eigenschaft Element liefert den generischen Typen zurück (weil du es so programmiert hast)

Njein. Element[Index] hat direkt den (Basis)typ zurueckgegeben. das war ja mein Verstendnisproblem.
Als generische Liste liefert Items[Index] natuerlich ein objekt des generischen Typs.
Ich hatte da noch die Denkweise vom ohne-Generics programmieren, wo eine TObjectList "nur" ein TObject liefert.
So liefert mir Items[] bei einer TBooleanList schon ein TBooleanClass zurueck ohne das ich das erst casten muss.

Kann man eigentlich einen generischen Typ definieren mit einem constructor der den standard Create() von TObject ueberschreibt?
Konstruktoren kann man ja nicht in einem IInterface deklarieren, oder?

[Schokohase]

Wir sprechen doch noch immer über diese Klasse?

Delphi-Quellcode:

type
  TListTypeGeneric<TDataObjectType:TDataTypeGeneric<TDataType>,IDataIO,constructor>=class(TObjectList)
  private
    function GetElement(Index: integer): TDataObjectType;
    procedure SetElement(Index: integer; const Value: TDataObjectType);
  protected
    function GetVString: string;virtual;
  public
    function AddNewElement : TDataObjectType;
    procedure LoadFromStream(AStream:TFileStream);
    procedure SaveToStream(AStream:TFileStream);
    property Element[Index:integer] : TDataObjectType read GetElement write SetElement;
    property VString : string read GetVString;   
  end;

Und da liefert Items ein TObject zurück und Elements den generischen Typ.

[Catweasel77]

Zitat:

Wir sprechen doch noch immer über diese Klasse?
Und da liefert Items ein TObject zurück und Elements den generischen Typ.

So hatte ich mir das auch gedacht.
Ich bezog mich auf die Loesung von jaenicke (Dateianhang).

[jaenicke]

Zitat von Catweasel77:

Kann man eigentlich einen generischen Typ definieren mit einem constructor der den standard Create() von TObject ueberschreibt?
Konstruktoren kann man ja nicht in einem IInterface deklarieren, oder?

Man muss zur Initialisierung ja keinen Konstruktor nehmen. Im Gegenteil, das hat z.B. den Nachteil, dass man die Intialisierungsdaten schon beim Erstellen des Objekts kennen muss. Zudem werden Exceptions dann anders (oft nicht wie gewollt) behandelt.

Man kann das in den aktuellen Versionen aber auch so lösen. Man muss für den Typ lediglich einen Type Constraint auf eine Vorfahrklasse angeben, die einen passenden Konstruktor hat. Ich würde aber lieber eine Methode Init verwenden.

[Rudy Velthuis]

Zitat von Catweasel77:

Zitat:

Aber, wenn ich es richtig sehe, kann man das, was du machst, genauso gut ohne machen.

Naja, so gesehen kann man alles was man mit Generics machen kann auch ohne machen.

Ich meine, dass du das, wofür man Generics eigentlich braucht, gar nicht benutzt. Dein Code benutzt die Generics ja gar nicht. Es gibt Code, den kann man ohne Generics so nicht machen. Dein Code benutzt gar keine Generics, also kannst du sie genauso gut weglassen.

Nicht alles was spitze Klammern benutzt ist gleich "Generics". Generics bedeutet, dass du die typ-abhängigen Methoden einer Klasse nur einmal schreibst, mit einem Platzhalter (wie z.B. <T>) für den tatsächlichen Typ, und dann später für den Platzhalter einen konkreten Typ einsetzt. Das tust du ja gar nicht. Deine einzige typ-abhängige Methode wird für jeden Typ neu geschrieben. Also nutzt du die Generics ja gar nicht, du nutzt immer noch die Vererbung.

[Catweasel77]

@jaenicke

Zitat:

Man muss zur Initialisierung ja keinen Konstruktor nehmen. Im Gegenteil, das hat z.B. den Nachteil, dass man die Intialisierungsdaten schon beim Erstellen des Objekts kennen muss.

Bei einfachen Datentypen ja. Aber was wenn der DatenTyp eine Klasse mit Objekt members ist, z.b.:

Delphi-Quellcode:

uses
  Classes, UDataTypes;

type
  TPerson=class(TInterfacedObject, IDataIO)
  private
    FName : TStringClass;
    FAge : TIntegerClass;
    function GetAge: TIntegerClass;
    function GetName: TStringClass;
    function GetVString: string;
  public
    constructor Create;reintroduce;
    destructor Destroy;reintroduce;
    procedure LoadFromStream(AStream: TFileStream);
    procedure SaveToStream(AStream: TFileStream);
    property Name : TStringClass read GetName;
    property Age : TIntegerClass read GetAge;
    property VString : string read GetVString;
  end;

{ TPerson }

constructor TPerson.Create;
begin
  inherited;
FName := TStringClass.Create;
FAge := TIntegerClass.Create;
end;

destructor TPerson.Destroy;
begin
FName.Free;
FAge.Free;
  inherited;
end;

Hier waere es schon gut wenn der Konstruktor laeuft und FName uund FAge erzeugt werden.
Wenn ich jetzt noch nach aehnlichem Muster THund, TKatze, TMaus erstelle und eine generische Objektliste haben will mit einer AddElement() Methode die ein Objekt dieses Typs erzeugt, zur Liste hinzufuegt und zurueckgibt:

Delphi-Quellcode:

type
  TMyObjectList<TObjType:class,constructor,IDataIO> = class(TObjectList<TObjType>)
  private
  public
    function AddNewElement : TObjType;
  end;

  TPersonList = TMyObjectList<TPerson>;


{ TMyObjectList<TObjType> }

function TMyObjectList<TObjType>.AddNewElement: TObjType;
begin
Result := TObjType.Create;
Add(Result);
end;

Neue Listenelemente werden (so ist es gedacht) immer nur von der Liste erzeugt. Es ist nicht vorgesehen das ein TPerson erzeugt wird und dann er Klasse zugewiesen wird (normale Add() Methode).

Deswegen meine Frage nache dem Verhalten des Konstruktors. In der Doku hatte ich naemlich gelesen das der 'constructor' constraint nur den parameterlosen Create() Konstruktor von TObject bereitstellt....

[Catweasel77]

@Rudy Velthuis

Zitat:

Das tust du ja gar nicht. Deine einzige typ-abhängige Methode wird für jeden Typ neu geschrieben

Hmm.. Das ist der Teil der nur einmal geschrieben ist:

Delphi-Quellcode:

{ TDataTypeGeneric<TDataType> }


function TDataTypeGeneric<TDataType>.GetData: TDataType;
begin
Result := FData;
end;

procedure TDataTypeGeneric<TDataType>.LoadFromStream(AStream: TFileStream);
begin
AStream.Read(FData,SizeOf(FData));
end;

procedure TDataTypeGeneric<TDataType>.SaveToStream(AStream: TFileStream);
begin
AStream.Write(FData,SizeOf(FData));
end;

procedure TDataTypeGeneric<TDataType>.SetData(const Value: TDataType);
begin
FData := Value;
end;

Lediglich eine Methode fuer die Stringumwandlung ist ueberschrieben, weil das eben fuer jeden Typ unterschiedlich ist.

Delphi-Quellcode:

{ TIntegerClass }

function TIntegerClass.GetVString: string;
begin
Result := IntToStr(FData);
end;


{ TFloatClass }

function TFloatClass.GetVString: string;
begin
Result := FloatToStr(FData);
end;


{ TBooleanClass }

function TBooleanClass.GetVString: string;
begin
Result := BoolToStr(FData,true);
end;

Bei der StringKlasse musste ich noch die Stream Methoden ueberschreiben wegen dem "PChar()^" anstelle von einfach nur "FData"..

Delphi-Quellcode:

{ TStringClass }

function TStringClass.GetVString: string;
begin
Result := FData;
end;

procedure TStringClass.LoadFromStream(AStream: TFileStream);
var
size : longint;
begin
AStream.Read(size,SizeOf(size));
setlength(FData,size div SizeOf(char));
AStream.Read(PChar(FData)^,size);
end;

procedure TStringClass.SaveToStream(AStream: TFileStream);
var
size : longint;
begin
size := length(FData) * SizeOf(char);
AStream.Write(size,SizeOf(size));
AStream.Write(PChar(FData)^,size);
end;

Wie wolltest du denn den Data property getter und setter fuer beliebige Typen ohne Generics implementieren??