was ist der Sinn von Templates/Generics ?

[jaenicke]

Zitat von paule32.jk:

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

Ja, du kannst den generischen Typ dabei durch einen konkreten Typ ersetzen, also TSubClass = class(TMyValue<Integer>) , oder wieder nach außen als neuen generischen Typ durchreichen, also TSubClass<T> = class(TMyValue<T>) . Beides habe ich schon sehr oft verwendet.

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

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

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

[paule32.jk]

ich habe nun folgendes...

Delphi-Quellcode:

unit QCharClass;

interface
type
    QChar<T> = class
    protected
        function getOrigin: uint64;
    public
        constructor Create; overload;
        ...
    end;

implementation

function check_ptr(name: PChar; ptr: uint64): Boolean;
begin
  result := false;
  if ptr = 0 then
  begin
    ErrorMessage(PChar(Format('Error: %s not constructed.',[name])));
    exit;
  end;
  result := true;
end;

constructor QChar<T>.Create;
begin
    inherited Create;

    if not check_ptr(ClassName, getOrigin) then
    begin Free; exit; end;
end;

end.

ergibt dann:

Code:

[dcc64 Fehler] QCharClass.pas(429): E2506 Im interface-Abschnitt deklarierte Methode des parametrisierten Typs darf kein lokales Symbol 'check_ptr' verwenden

heißt das nun, ich kann keine Funktionen/Prozeduren im implementation's-Bereich stehen, und nicht direkt mit der QChar<T> zu tun haben, mehr schreiben ?

[Uwe Raabe]

Bei einer generischen Klasse kann der Compiler den eigentlichen Code erst erzeugen, wenn der tatsächliche Typ von T bekannt ist. Daher gibt es diese Einschränkung.

Alternativ kannst du die function check_ptr als Methode der Klasse deklarieren (dann wäre sie ja auch im Interface Part) oder als lokale function innerhalb von QChar<T>.Create (wenn sie nicht noch anderswo verwendet wird).

Abgesehen davon sieht man in deinem Code gar nicht, warum er überhaupt generisch ist. Das T wird nirgendwo verwendet - zumindest nicht in dem Teil den du zeigst. Ich bringe das deswegen auf den Tisch, da es manchmal sinnvoller ist, eine nicht generische Basisklasse zu haben und von der dann ein generische Ableitung zu erstellen, die sich rein um den generischen Part kümmert.

Delphi-Quellcode:

type
    QChar = class
    protected
        function getOrigin: uint64;
    public
        constructor Create; overload;
        ... // alles was nicht mit T zu tun hat
    end;

    QChar<T> = class(QChar)
      ... // alles was mit T zu tun hat
    end;

implementation

function check_ptr(name: PChar; ptr: uint64): Boolean;
begin
  result := false;
  if ptr = 0 then
  begin
    ErrorMessage(PChar(Format('Error: %s not constructed.',[name])));
    exit;
  end;
  result := true;
end;

constructor QChar.Create;
begin
    inherited Create;

    if not check_ptr(ClassName, getOrigin) then
    begin Free; exit; end;
end;

Übrigens: das Free innerhalb des Create ist etwas irritierend.

[himitsu]

Wozu Free?
Erst garnicht erzeugen, wenn nicht nötig oder möglich.

Delphi-Quellcode:

type
  QChar = class
  private // or protected or public
    class function check_ptr(name: PChar; ptr: uint64): Boolean; static;
  protected
    function getOrigin: uint64;
  public
    //constructor Create;
    //class function Create: QChar; static;  // intern nur dann erzeugen, wenn nötig
    class function CreateOrNot: QChar; static;  // da dieses "Create" unerwartet auch NIL zurückgeben kann, sollte das auch ersichtlich sein.
  end;

class function QChar.check_ptr(name: PChar; ptr: uint64): Boolean;
begin
  Result := ptr <> 0;
  if not Result then
    ErrorMessage(PChar(Format('Error: %s not constructed.',[name])));
end;

class function QChar.CreateOrNot: QChar;
begin
  Result := nil;
  if check_ptr(ClassName, getOrigin) then
    Result := inherited Create;
end; 



x := QChar.CreateOrNot;
if Assigned(x) then
  ...

[paule32.jk]

Zitat von Uwe Raabe:

Delphi-Quellcode:

type
    QChar = class
    protected
        function getOrigin: uint64;
    public
        constructor Create; overload;
        ... // alles was nicht mit T zu tun hat
    end;

    QChar<T> = class(QChar)
      ... // alles was mit T zu tun hat
    end;

das sieht sehr gut aus !

Zitat von Uwe Raabe:

Übrigens: das Free innerhalb des Create ist etwas irritierend.

das Free ist von mir dazu gedacht, den Speicher freizugeben, wenn bei der Überprüfung der Pointer nil ergibt.
Man könnte das auch auslagern. Aber ich dachte mir, da der Code in einer DLL liegt, das auslösen einer Exception nicht so dolle erscheinen mag.

das ganze kann auch hier eingesehen werden.