Marco Tech Blog

May 9, 2011

Delphi Tech Tip 02: Retuning Derived Type

A second tech tip... unveiling why I suggested the first one. How to change the return type of a function in a derived class.

function TBase.Get (name: string): TBase;

function TDerived.Get (name: string): TDerived;

      emp := TEmployee.Get(4) as TEmployee;
    

emp := TEmployee.Get(4);
    

posted by marcocantu @ 8:47PM | 5 Comments [0 Pending]

Delphi Tech Tip 02 Retuning Derived Type 

I'd rather go the explicit way and separate the
polymorphic part from the covariant part:

TBase = class
protected
  function DoGet (const Name: String): TBase; virtual;
abstract;
public
  function Get (const Name: String): TBase;
end;

TDerived = class (TBase)
protected
  function DoGet (const Name: String): TBase; override;
public
  function Get (const Name: String): TDerived;
reintroduce;
end;

function TBase.Get (const Name: String): TBase;
begin
  Result := DoGet (Name);
end;

function TDerived.Get (const Name: String): TDerived;
begin
  Result := { get a TDerived somewhere };
end;

function TDerived.DoGet (const Name: String): TBase;
begin
  Result := Get (Name);
end;

This resembles covariant return types as closely as
possible.

FWIW, for those who use C++Builder, C++ supports
covariant return types directly.

Comment by Moritz Beutel [http://www.audacia-software.de] on May 10, 00:03

Delphi Tech Tip 02 Retuning Derived Type 

Moritz, 

that's a very clean approach and I like it. However, I'd 
rather avoid having to write code for each of the 
(dozens of) derived subclasses, and this is what the 
generic method does. I generally do not override Get (as 
this is a standard implementation) nor GetAs (as this is 
a "generic" implementation) in the specific classes.

Thanks a lot for the post and the C++ info, though.

Comment by Marco Cantu [http://www.marcocantu.com] on May 10, 06:48

Delphi Tech Tip 02 Retuning Derived Type 

Marco, your code example looks to me like "the" big
no-no of overloading, as it's more of an obfuscation
than a clarification.

Specific getters should get specific names, rather
than overload the higher level ones, otherwise the
code can break in too many ways as those Getter can
have a life of their own, classes can be added to the
hierarchy, etc. It's not like a virtual override,
you're changing the meaning of the code depending on
the type of the variables, rather than the concrete
object type.

It may look cool the first time you write it, but in
the long run, it's a maintainance disaster in waiting.

Just my 2 cents of experience with such overloads.

Comment by John [] on May 10, 07:47

Delphi Tech Tip 02 Retuning Derived Type 

I usualy write something like this:

{ interface part }
type
  TBase = class
  public
    function Get(name: string): TBase;
  end;
  TDerived = class(TBase)
  public
    function Get(name: string): TDerived;
  end;


{ implementation part }
function TBase.Get(name: string): TBase;
begin
  Result := { get result }
end;

function TDerived.Get(name: string): TDerived;
begin
  Result := TDerived(inherited Get(name));
end;

Comment by rkovac on May 10, 11:15

Delphi Tech Tip 02 Retuning Derived Type 

... or use generics

TBase = class;
TBaseClass = class of TBase;

TBase = class
public
  function Get<T=TBaseClass>(const Name: String): T;
end;

and your implementation creates a new object of type T
which can be decorated etc before passing back.

Cheers

D

Comment by David Moorhouse on May 10, 20:38