Darf man Felder und Property's überschreiben?

[DrUArn]

Hi,
ein Thread zieht den nächsten nach sich:

Das Problem - siehe meine letzte Diskussion:

Delphi-Quellcode:

type

tmyobj1=class(tobject)
    A:integer;
  end;
  
 tmyobj2=class(tmyobj1)
   B:string;
  end;
  
 TMyList1withtmyobj1 = class(TobjectList)
     procedure verarbeiteA;
  end;
  
 TMyList2withmyobj2 = class(TMyList1withtmyobj1)
    procedure verarbeiteAundB;
  end; 


tmyrich1=class(trichedit)
  private
   FMylist:TMyList1withtmyobj1
  public
   property mylist: :TMyList1withtmyobj1 read FMylist write FMylist;
   constructor Create(aOwner:tcomponent); override;//mylist erzeugt
end;

type tmyrich2=class(tmyrich1)
  private
   FMylist:TMyList2withtmyobj2;
  public
   property mylist: :TMyList2withtmyobj2 read FMylist write FMylist;
  constructor Create(aOwner:tcomponent); override;//mylist löschen und erzeugen
end;


constructor tmyrich1.Create;
begin
  inherited;
  FMylist:=TMyList1withtmyobj1.create;
end;

constructor tmyrich2.Create;
begin
  inherited;
  inherited Mylist.free;
  FMylist:=TMyList2withtmyobj2.create;
end;

Zu wem gehören meine zweimal definierten Felder fmylist?
Schreibe ich constructor tmyrich2.Create nicht, ist in tmyrich2, da .create
von tmyrich1 genutzt wird, fmylist= nil.

Nutze ich constructor tmyrich2.Create und erzeuge die Liste nochmal, greifen auch Routinen aus Tmyrich1 ordnubngsgemäß auf Feld fmylist respektive property mylist zu.

Darf man so arbeiten?

Gruß Uwe

[jfheins]

Zitat von DrUArn:

[...]
Zu wem gehören meine zweimal definierten Felder fmylist?
Schreibe ich constructor tmyrich2.Create nicht, ist in tmyrich2, da .create
von tmyrich1 genutzt wird, fmylist= nil.

Es ist unschön. du solltest vielleicht noch einen Parameter in den Constructor einfügen, ob die Liste erzeugt werden soll.

Zitat von DrUArn:

Darf man so arbeiten?
Gruß Uwe

Es sieht ein bisschen komisch aus (Ableiten von Objektlisten ?) aber wenn diese Konstruktion dein Problem am besten löst, dann Ja.
Bei deinen Beispielbezeichnern kommt jetzt nicht so raus, dass da tatsächlich eine "ABC ist ein XYZ"-Beziehung besteht wenn du ableitest.

[Jumpy]

Und was passiert, wenn du ein tmyrich2 in ein tmyrich1 castest, bzw. in einer entsprechenden Variablen speichert. Ist dann nicht auch wieder mylist=nil, diesmal die von tmyrich1???

[himitsu]

Felder kann man sowieso nicht überschreiben.
In diesem Fall entstehen 2 Felder, welche zufällig den selben Namen besitzen, aber sonst haben die nichts gemeinsam.

tmyrich2 besitzt also unabhängige 2 Listen und daran ändert auch ein Casten nichts mehr.

Property kann man auch nicht überschreiben, aber man kann sie verdecken, erweitern oder verschieben.

property Xyz; in einen anderen Sichbarkeitsbereich geschrieben, verschiebt die Sichtbarkeit und dessen Nachfahren.
(in einen Vorfahrentypen gekastet ergibt sich aber wieder die alte sichtbarkeit, weswegen man die Sichbarkeit eigentlich nicht wieder verringern kann/sollte)

z.B. property Xyz stored False; oder property Xyz default True; verändert ein paar Eigenschaften, welche von den Streamingklassen verwendet werden.

Und dann das Verdecken:
Wenn es im Vorfahren schon ein Property Xyz gibt und man es neu "erstell" property Xyz: TXyz2 read FXyz write SetXyz; , dann ist in der Klasse und den Nachfahren die neue Deklaration sichbar und die Alte nicht.
(auch hier, wenn man über eine Vorfahrenklasse drauf zugreift, dann kommt man wieder an das alte Property ran und vom Neuen ist nix mehr zu merken)
Soll die Funktion "definitiv" verändert werden, dann benötigt man einen überschreibbaren Getter/Setter, für dieses Property.

[DrUArn]

Hi,

das mein Konstrukt überhaupt funktionierte, lag hieran:

Delphi-Quellcode:

constructor tmyrich2.Create;
 begin
   inherited;
{->>>}   inherited Mylist.free;
   FMylist:=TMyList2withtmyobj2.create;
 end;

Diese Liste wird zwar gelöscht, ihr Speicher scheint aber noch ein bißchen erhalten zu bleiben.

Delphi-Quellcode:

constructor tmyrich2.Create;
 begin
   inherited;
   inherited Mylist.free;
{->>>}    inherited MyList:=nil;
   FMylist:=TMyList2withtmyobj2.create;
 end;

führt zum Griff ins nirwana-nil, wenn der Vorgänger auf "seine" Liste zugreifen will.

@Himitsu hat recht, es sind verschiedene Eigenschaften resp. Property's,
auf die jeweils in ihrem Gültikeitsbereich zugegriffen wird.

Damit muß ich meine Vorstellung, abgeleitete Listen in abgeleiteten Objekten ersetzen zu können, vergessen.
War 'ne Optimierungs-Vorstellung, nicht alles zweimal erfinden zu müssen.

Danke und Grüße Uwe

[Blup]

Mir ist noch nicht so ganz klar, was eigentlich erreicht werden soll, aber vieleicht so als Anregung:

Delphi-Quellcode:

type
  TMyObj1 = class(TObject)
    A:integer;
  end;
  
  TMyObj2 = class(TMyObj1)
    B:string;
  end;
  
  TMyList = class(TObjectList)
    procedure verarbeite; virtual; abstract;
  end;

  TMyList1 = class(TMyList)
    procedure verarbeite; override; {verarbeitet tmyobj1} 
  end;
  
  TMyList2 = class(TMyList) {oder class(TMyList1)}
    procedure verarbeite; override; {verarbeitet tmyobj2} 
  end;

  TMyRich = class(TRichEdit)
  private
    FMylist: TMyList;
    function GetMyList: TMyList;
  protected
    function CreateList: TMyList; virtual; abstract; 
  public
    property mylist: TMyList read GetMyList;
    destructor Destroy; override;
  end;

  TMyRich1 = class(TMyRich)
  protected
    function CreateList: TMyList; override;
  end;

  TMyRich2 = class(TMyRich)
  protected
    function CreateList: TMyList; override;
  end;

implementation

destructor TMyRich.Destroy;
begin
  FMylist.Free;
  inherited;
end;

function TMyRich.GetMyList: TMyList;
begin
  if FMylist = nil then
    FMylist := CreateList;
  Result := FMylist;
end;

function TMyRich1.CreateList: TMyList;
begin
  Result := TMyList1.Create;
end;

function TMyRich2.CreateList: TMyList;
begin
  Result := TMyList2.Create;
end;

[DrUArn]

Hi,

@Blup: Es sollen Funktionen und Proceduren der ersten auch in der zweiten Liste genutzt werden können, ebenso wie in den Objecten (z.b. trichedit), wo die Nachkommen erst auf Felder von der zweiten Liste zugreifen wollen.
Ich muß mir Deinen Eintrag nochmal langsam durchlesen.

Hier noch 'ne Idee:

Delphi-Quellcode:

constructor tmyrich2.Create;
  begin
    inherited;
    inherited Mylist.free;
    inherited MyList:=nil;
    FMylist:=TMyList2withtmyobj2.create;
{--->}    inherited mylist:= fMylist
  end;

Falls diese Gleichsetzung von der Vorgängerliste mit der Nachfolgerliste eine Gleichsetzung der Pointer und nicht etwa ein Kopieren des Inhaltes bewirkt, ist das vielleicht eine Lösung.
Zumindestens funktioniert jetzt das Programm.

Das kommt mir wie ein Casting der Listentypen vor.
Im tmyrich1 wird FMylist als TMyList1withtmyobj1 interpretiert und
im tmyrich2 wird FMylist als TMyList2withtmyobj2 genutzt wie geplant.


Güße Uwe