was ist der Sinn von Templates/Generics ?

[paule32.jk]

wenn man schreibt:

FooResult := TFoo<String>.Create('Hello Free Pascal'); kann man doch auch gleich den "Create" Konstrucktor überladen ?

Delphi-Quellcode:

type
  TFoo = class
  public
    Create; overload;
    Create(String);
    ...
  end;

oder seh ich da was falsches ?

[DeddyH]

Und das machst Du dann für jeden erdenklichen Datentyp inkl. selbstbdeklarierte?

[paule32.jk]

na irgendwie muss man doch dann doch prüfen, welcher Datentyp da dann übergeben wurde ?

im Fall von TFoo<String>.Create

in etwa so: IF Type = String THEN ...

also ich seh da keinen echten Mehrwert.

[DeddyH]

Wieso musst Du das prüfen? Wenn ich eine TList<TBla> deklariere, dann weiß ich, dass da nur TBla-Elemente enthalten sein können.

[jaenicke]

Zitat von paule32.jk:

na irgendwie muss man doch dann doch prüfen, welcher Datentyp da dann übergeben wurde ?

im Fall von TFoo<String>.Create

in etwa so: IF Type = String THEN ...

also ich seh da keinen echten Mehrwert.

Du willst ja gerade etwas machen, das für mehrere Datentypen gilt. Zum Beispiel eine Liste TList<Integer> oder TList<TForm>. Darin unterscheidest du aber nicht die ganzen konkreten Typen.

Dann hätte das wirklich keinen Mehrwert.

[paule32.jk]

also ein Erweiterung von: TList.Objects (die ja nur auf Pointer ausgelegt sind)
obwohl, da könnte man doch auch einen Cast anlegen ?

Weil, wofür sollte man Datentypen im Code behandeln, die vorher nicht bekannt sind ?

[DeddyH]

Generics sind dafür gedacht, generischen Code zu schreiben( ja, daher der Name). Das bedeutet, dass man Code entwickelt, der nicht auf einen bestimmten Datentyp festgelegt ist. Zur Compiletime wird der generische Platzhalter dann durch den konkret benutzten Datentyp ersetzt.

[jaenicke]

Ein kleines Beispiel:

Delphi-Quellcode:

uses
  System.Generics.Collections;

type
  TMyValue<T> = class
  private
    FValue: T;
    procedure SetValue(const Value: T);
  public
    property Value: T read FValue write SetValue;
  end;

procedure Test;
var
  ValInteger: TMyValue<Integer>;
  ValList: TMyValue<TList<Integer>>;
begin
  ValInteger := TMyValue<Integer>.Create;
  try
    ValInteger.Value := 42;
    ShowMessage(ValInteger.Value.ToString);
  finally
    ValInteger.Free;
  end;

  ValList := TMyValue<TList<Integer>>.Create;
  try
    ValList.Value := TList<Integer>.Create;
    ValList.Value.Add(11);
    ValList.Value.Add(33);
    ValList.Value.Add(42);
    ShowMessage(ValList.Value[2].ToString);
  finally
    ValList.Free;
  end;
end;

procedure TMyValue<T>.SetValue(const Value: T);
begin
  FValue := Value;
end;

In echtem Code wird das natürlich deutlich umfangreicher. Aber für den Anfang sollte das reichen.

[paule32.jk]

oh Danke.
dachte ich mirs doch: Generics = Vorlagen und Erweiterung von Cast/Pointern, so dass statt einen Pointer, ein konkreter Datentyp bezeichnet/gekennzeichnet wird.

macht Sinn...
anstelle mit Pointern zu jonglieren, ist dann durch Generics gewährleistet, welcher Typ verwendet wird...

ohne das jetzt getestet zu Haben:
- können Generics "vererbt" werden (also die Klassen durch Sub-Classing erweitert werden ?

[DeddyH]

Hab ich zwar noch nicht gemacht, aber wieso sollte das nicht gehen? Man muss halt darauf achten, dass die Ableitung auch wieder generisch ist.