Vererbungsprobleme

[Rainer Wolff]

Irgendwie steh ich bei der Vererbung grad auf dem Schlauch.

Ich habe eine Klasse von TObjectlist abgeleitet und (unter anderem) die Add-Methode überschrieben.

TMyObjectList = class(TObjectList)
function Add(AObject: TMyObject): Integer;reintroduce; virtual;
end;

function TMyObjectList.Add(AObject: TMyObject): Integer;
begin
inherited Add(AObject);
MachSonstNochWas;
end;

Ich übergebe meine Liste an eine Funktion einer anderen Klasse, die ein Objekt erzeugt und der Liste hinzufügt.

procedure TAnotherclass.Tuwas(ObjectList: TObjectList);
MyObject:=TMyObject.Create;
Objectlist.Add(MyObject);

An dieser Stelle wird jedoch die Add-Funktion der Basisklasse Objectlist aufgerufen, nicht die Add-Funktion meiner abgeleiteten Klasse, die SonstNochWas erledigen sollte.

Nur wenn ich in meiner procedure Tuwas aus der TObjectlist eine TMyObjectlist mache, funktioniert das ganze.
Ich will aber meine TAnotherclass nicht von meiner TMyObjectlist abhängig machen, die soll auch mit einer TObjectlist funktionieren.

Wie ist dieses Problem zu lösen?

Gruß Rainer

[Hansa]

Zitat von Rainer Wolff:

..eine Klasse von TObjectlist abgeleitet und (unter anderem) die Add-Methode überschrieben.

Du hast sie nicht überschrieben (das wäre "override") sondern rufst sie gezielt noch mit inherited direkt auf !

[Kroko1999]

Delphi-Quellcode:

TMyObjectList = class(TObjectList)
function Add(AObject: TMyObject): Integer;override;
end;

EDIT: zu Lahm

[Rainer Wolff]

overriden kann ich aber nicht, da Add in TObjectlist nicht als virtuell markiert ist

Rainer

[Hansa]

Jo, eben Pech gehabt. Du musst eben sogar zurück bis zur TList und das Add komplett neu erfinden. Alternative : Vorgehensweise neu überdenken.

[shmia]

Ich würde die Add() Methode nicht überschreiben, sondern eine neue Methode (z.B. AddObject) einführen.
Damit umgehst du die Probleme.
Du könntest sogar eine weitere Komfortfunktion dazupacken:

Delphi-Quellcode:

// Object erzeugen und in die Liste anfügen in einem Aufwasch
function TMyObjectList.CreateAndAdd:TMyObject;
begin
  result := TMyObject.Create;
  AddObject(result);
end;

[Muetze1]

Zitat von shmia:

Ich würde die Add() Methode nicht überschreiben, sondern eine neue Methode (z.B. AddObject) einführen.
Damit umgehst du die Probleme.

In wie fern denn? Wir sind schon bei einer TObjectList, somit ist Add() schon für Objekte. Du willst nun AddObject() deklarieren die dann zu dem Objekt noch ein Objekt annimmt? In wie fern umgeht man damit die Probleme?

Und nun zu dem Problem: Du kannst Add() neu implementieren, aber nicht überschreiben, da nicht als dynamisch oder virtuell deklariert, ist ok. Aber das ist nicht so schlimm, lass einfach das ReIntroduce weg (ist eh nicht virtuell oder dynamisch, somit besteht überhaupt kein Anlass dafür) und beseitige das eigentliche Problem an der folgenden Stelle:

Zitat von Rainer Wolff:

Delphi-Quellcode:

procedure TAnotherclass.Tuwas(ObjectList: TObjectList);
  MyObject:=TMyObject.Create;
  Objectlist.Add(MyObject);

Du übergibst die Listenklasse mit deren Basisklasse. Da du Add() nicht überschreiben kannst (höchstens verdecken, etc), wird deine abgeleitete Add() Funktion niemals aufgerufen, ausser du spezialisierst die Klasse zuvor oder du übergibst diese schon in der spezialisierten Form. Also entweder so:

Delphi-Quellcode:

procedure TAnotherclass.Tuwas(ObjectList: TMyObjectList);
  MyObject := TMyObject.Create;
  Objectlist.Add(MyObject);

Oder halt spezialisieren:

Delphi-Quellcode:

procedure TAnotherclass.Tuwas(ObjectList: TObjectList);
  MyObject := TMyObject.Create;
  ( Objectlist As TMyObjectList ).Add(MyObject);

[Rainer Wolff]

So ähnlich hatte ich das inzwischen auch gelöst.

Delphi-Quellcode:

TMyAnotherClass = class(TAnotherClass)
  procedure TuWas(ObjectList: TMyObjectList)
end

procedure TMyAnotherclass.Tuwas(ObjectList: TMyObjectList);
  MyObject:=TMyObject.Create;
  Objectlist.Add(MyObject);

Schade, daß es nicht ohne diesen Umweg zu machen ist.

Danke für die Hilfe

Rainer

[KrasserChecker]

Hi,
doch es ist ohne diesen Umweg zu machen.
Wenn Du dir die Definition von "TObjectList" anschaust erkennst Du, daß zwar nicht die Methode "Add", wohl aber die Methode "Notify" überschrieben werden kann. Über diese Methode wird gemeldet, welche Aktion gerade passiert ist.

In deiner Ableitung müsste also nur das hier stehen:

Delphi-Quellcode:

protected
    procedure Notify(Ptr: Pointer; Action: TListNotification); override;

[...]

procedure TMyObjectList.Notify(Ptr: Pointer; Action: TListNotification);
begin  
  inherited Notify(Ptr, Action);

  if Action = lnAdded then
    MachSonstNochWas; 
end;

[Muetze1]

Zitat von KrasserChecker:

Hi,
doch es ist ohne diesen Umweg zu machen.
Wenn Du dir die Definition von "TObjectList" anschaust erkennst Du, daß zwar nicht die Methode "Add", wohl aber die Methode "Notify" überschrieben werden kann. Über diese Methode wird gemeldet, welche Aktion gerade passiert ist.

Es ist aber ein recht grosser Unterschied, wenn TuWas() als Code ...

1. ...in der Liste steht
2. ...ausserhalb der Liste beim Benutzer der Liste steht
3. ...Im Objekt selber steht was in der Liste verwaltet wird.

Du bietest eine Lösung an, welche die Implementierungsstelle komplett in eine andere Datenkapselung verschiebt. Es ist für eine Listenklasse zur Verwaltung der Liste definitiv nicht zu zu muten etwas speziell für ein Objekt seiner Liste zu machen. Du verschiebst diesen Code über die Kapselungen hinaus in eine andere Kapselung die damit nichts mehr gemein hat.