Eine Frage zu Generics in generischen Listen

[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.

Stell dir diese Klasse vor:

Delphi-Quellcode:

type
  TIntegerClass=class(TObject)
  private
    FData : longint;
    function GetData: longint;
    procedure SetData(const Value: longint);
    function GetVString: string;
  public
    procedure LoadFromStream(AStream:TFileStream);
    procedure SaveToStream(AStream:TFileStream);
    property Data : longint read GetData write SetData;
    property VString : string read GetVString;
  end;

Und das eben als Generic fuer beliebige Typen... Ich will aber nicht den Quellcode duplizieren und einfach nur den typ ersetzen...
Dasselbe bei der Liste

Die IntegerListe waere dann das hier (aber als Generic fuer alle Typen die ich aus dem datenTyp Generic bastel):

Delphi-Quellcode:

type
  TIntegerList=class(TObjectList)
  private
    function GetElement(Index: integer): TIntegerClass;
  public
    function AddNewElement : TIntegerClass;
    procedure LoadFromStream(AStream:TFileStream);
    procedure SaveToStream(AStream:TFileStream);
    property Element[Index:integer] : TIntegerClass read GetElement;
  end;

Das klappt ja auch. Nur die Liste, bzw. jetzt die Element[] property gibt mir noch raetsel auf...

[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??