Hallo,

ich versuche mich etwas intensiver mit generischen Klassen. Dazu habe ich mir folgendes Beispiel erstellt:

zusammenfalten · markieren

Delphi-Quellcode:

program MyProject;

{$R *.res}

uses
  System.SysUtils,
  System.Generics.Defaults,
  System.Generics.Collections,
  MyUnit in 'MyUnit.pas';

type
 TMyNewObj<T> = class(TMyObj<T>)
 private
  procedure MyUsedProc; virtual;
 end;

 TMyNew = class(TMyNewObj<double>)
// private
// procedure MyUsedProc; virtual;
 end;

var
 MyNewObj : TMyNew;

{ TMyNewObj<T> }

procedure TMyNewObj<T>.MyUsedProc;
begin
 writeln('Hello MyNewObj<T>');
 writeln(FValInt.ToString);
 readln;
end;

//{ TMyNew }
//
//procedure TMyNew.MyUsedProc;
//begin
// writeln('Hello MyNew');
// writeln(FValInt.ToString);
// writeln(Format('%0.2f',[FVal]));
// readln;
//end;

begin
 try
  { TODO -oUser -cConsole Main : Code hier einfügen }
  MyNewObj:=TMyNew.Create;
  MyNewObj.Val:=1.2345;
  MyNewObj.MyUseTheUsedProc; //<- Hier kommt der Fehler, bzw. ...siehe weiter unten...in MyUnit
 except
  on E: Exception do
   Writeln(E.ClassName, ': ', E.Message);
 end;
 FreeAndNil(MyNewObj);
end.

zusammenfalten · markieren

Delphi-Quellcode:

unit MyUnit;

interface
uses
  System.SysUtils,
  System.Generics.Defaults,
  System.Generics.Collections;

type
 TMyObj<T> = class(TObject)
 private
  FVal : T;
  FValInt : integer;
  procedure MyUsedProc; virtual; abstract;
 public
  procedure MyUseTheUsedProc;
  property Val: T read FVal write FVal;
 end;

implementation

{ TMyObj<T> }

procedure TMyObj<T>.MyUseTheUsedProc;
begin
 MyUsedProc; //Hier kommt der Fehler dann...
end;

end.

Wenn ich MyNewObj.MyUseTheUsedProc aufrufe erhalte ich die Meldung 'Abstracter Fehler'. Es wird also die in TMyNewObj Prozedur MyUsedProc nicht aufgerufen, sondern die ursprüngliche - und das verstehe ich im Augenblick nicht.

Wo denke ich da falsch? Ich würde das gern verstehen...aber vielleicht verstehe ich das Konzept der generischen Klassen etc. noch nicht richtig...

Auskommentiert habe ich meine weiteren Versuche, bzw. ich würde gern mit der Definition TMyNew arbeiten - aber das klappt auch nicht...

FVal und FValInt sind nur so zum Testen enthalten, damit 'etwas mehr' da ist. Dass ich mit dem Typ 'double' probiere ist auch nur so zum Testen da - hat keinen tieferen Sinn.

Hi,
bei abgeleiteten Klassen solltest du eine virtuelle Procedure auch überschreiben. Siehe Beispiel unten. Dann müsste es eigentlich funktionieren.

markieren

Delphi-Quellcode:

type
  TMyNewObj<T> = class(TMyObj<T>)
  private
    procedure MyUsedProc; override; // <--- Ändere mal das virtual in override
  end;

Hi,

...da kommt die Meldung:
[dcc32 Fehler] MyProject.dpr(14): E2137 Methode 'MyUsedProc' nicht in Basisklasse gefunden.

Liegt wohl daran, das MyUsedProd als 'abstract' definiert ist.

MyUsedProc darf nicht private sein, sonst kann sie von der abgeleiteten Klasse nicht gesehen werden.

...yo...public und override...wobei ich override nicht verstehe, denn es ist eine abstrakte Methode...

Danke für die Hinweise!

Um genau zu sein, solltest du die Methode protected deklarieren (ausgehend davon, dass du sie ursprünglich private haben wolltest).

Warum verstehst du das override im Zusammenhang mit abstrakten Methoden nicht? Eine abstrakte Methode ist einfach eine Methode, die in der Basisklasse zwar deklariert, nicht aber implementiert wird.

Die Implementierung obliegt somit den abgeleiteten Klassen. Dass du explizit noch override angeben musst, ist in diesem Falle ganz normal. Dadurch weiß der Compiler, dass du tatsächlich die abstrakte Methode implementieren/überschreiben und nicht etwa verdecken willst.