was ist der Sinn von Templates/Generics ?

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

[himitsu]

Delphi-Quellcode:

TMyValue = class
  function GetValue<T>: T;
  procedure SetValue<T>(Value: T);
end;

TMyValue<T> = class
  function GetValue: T;
  procedure SetValue(Value: T);
end;


TMyValue<T> = class
  procedure Machwas<X>(Value: T; Other: X);
end;

Sie Weiteres auch in der OH/DocWiki.
* mehrere Typen können angegeben werden
* es können Einschränkungen Mindestanforderungen für diese Typen vorgegeben werben
* uvm.


Es kann sogar eine teilweise Automatik (Inferenz) genutzt, wo der Compiler z.B. anhand der übergebenen Variable das T selbst bestimmt.

Delphi-Quellcode:

MyValue.SetValue<Integer>(MyInt);
MyValue.SetValue(MyInt);

bei Value: T aber leider nicht bei Value: array of T

[paule32.jk]

Zitat von himitsu:

aber leider nicht bei Value: array of T

konnte ich mir schon Denken, da dies ein wenig blääedde ist ...
na gut, man kann nicht alles Haben (aber lieber auf der Bank ein Haben haben, als Soll zollen...)

[paule32.jk]

Delphi-Quellcode:

type
    QChar<T> = class
    public
        type
        QChar_Category = (
            Mark_NonSpacing       =  0,
            Mark_SpacingCombining =  1
        );
    private
        FCategory: QChar_Category;
    public
        constructor Create;
    published
        property Category: QChar_Category read FCategory default Other_NotAssigned;
    end;

bei oben stehenden Code erhalte ich dann die Meldung:

Code:

[dcc64 Fehler] QCharClass.pas(392): E2146 Standardwerte müssen vom Typ Ordinal, Pointer oder vom Typ small Set sein

und beim default Constructor erhalte ich dann:

Code:

constructor QChar.Create;
[dcc64 Fehler] QCharClass.pas(419): E2003 Undeklarierter Bezeichner: 'QChar'

constructor QChar<T>.Create; funktioniert dann wieder (als member function).

Ich habe das jetzt noch nicht weiter getestet; aber: dann ist ja auch:

Code:

foo := QChar.Create;

nicht möglich, weil, dann fehlt ja Typ, den man eigentlich mit <T> im Epilog des Klassen-Codes angegeben hat ?

[jaenicke]

Zitat von paule32.jk:

bei oben stehenden Code erhalte ich dann die Meldung:

Code:

[dcc64 Fehler] QCharClass.pas(392): E2146 Standardwerte müssen vom Typ Ordinal, Pointer oder vom Typ small Set sein

Das ist richtig, aber du kannst das ja auch im Code setzen.

[himitsu]

Wie gesagt, man kann die Deklaration des Generics an den Typ/Klasse hängen, dann muß es immer angegeben werden, und betrifft die ganze Klasse.

Oder man hängt ihn an die Methode(n), wo es dann jeweils nur diese Methode betrifft und man den Typen selbst auch ohne nutzen kann.

Oder man definiert sich eben einen aufgelösten Alias Typen damit.

Delphi-Quellcode:

type
  QChar<T> = class
    ...
  end; 

  QChar = QChar<string>;

Zitat von paule32.jk:

konnte ich mir schon Denken, da dies ein wenig blääedde ist ...

Betrifft nur die Automatik ... wenn man das <xyz> angibt, dann geht's.

[paule32.jk]

Zitat von himitsu:

bei Value: T aber leider nicht bei Value: array of T

also ich habe jetzt folgendes vom Compiler übersetzen können:

Delphi-Quellcode:

constructor QChar<T>.Create(v: Array of T);
var
    i: Integer;
begin
    for i := 0 to High(v) do
    foo := v[i];
end;

irgendwie finde ich das Klasse, was man so machen kann - zumal man auch Code sparrt ...

[himitsu]

Zitat von himitsu:

Es kann sogar eine teilweise Automatik (Inferenz) genutzt werden, wo der Compiler z.B. anhand der übergebenen Variable das T selbst bestimmt.

Delphi-Quellcode:

MyValue.SetValue<Integer>(MyInt);
MyValue.SetValue(MyInt);

bei Value: T aber leider nicht bei Value: array of T