Tag!

Leider steh ich gerade ziemlich auf der Leitung - daher ein Hilferuf:
(Aja: Delphi7, WinXP, falls es interessiert)

ich möchte eine Referenz auf ein Objekt an ein anderes Objekt übergeben und diese Referenz dort speichern. Unter Umständen wird das Objekt aber erst nach dieser Übergabe erzeugt - geht das? Wenn ja, wo ist mein Fehler?

Schaut also so aus:

markieren

Code:

TKlasse1=class(TObject)
  <viele Variablen, Funktionen, Prozeduren und so>
end;

TKlasse2=class(TObject)
  <auch viele Variablen, Funktionen, Prozeduren und so>
  fKlasse1:TKlasse1;
  constructor Create(Klasse1:TKlasse1);
end;

constructor TKlasse2.Create(Klasse1:TKlasse1);
begin
  <blabla>
  fKlasse1:=Klasse1;
end;

und dann gibts da noch:

markieren

Code:

TForm1=class(TForm)
  <...>
  Klasse1:TKlasse1;
  Klasse2:TKlasse2;
  <...>
end;

<...>
  Klasse2:=TKlasse2.Create(Klasse1);
<...>
  Klasse1:=TKlasse1.Create;

Läuft's genau so ab, ist beim Create der Klasse2 die Klasse1 noch nil - und die Variable fKlasse1 in der Klasse2 bleibt auf ewig nil.
Ist die Klasse1 zum Zeitpunkt des Creates der Klasse2 schon erzeugt dann gehts.

Jetzt kann ich natürlich die Sache so umbauen, daß die Klasse2 immer vorher erzeugt wird - aber das ist im aktuellen Fall erstens nicht schön und zweitens interessiert mich, ob ich wirklich auf'm Schlauch steh oder ob das irgendwie geht...

Danke
Luggi

Hi,

momentan übergibst du eine Objektreferenz (bzw. nil, wenn du das Objekt noch nicht erzeugt hast).
Das was du vorhast, lässt sich mit einer Referenz auf eine Objektreferenz lösen.

zusammenfalten · markieren

Delphi-Quellcode:

type
  TKlasse1 = class(TObject)
    // viele Variablen, Funktionen, Prozeduren und so ...
  end;
  PKlasse1 = ^TKlasse1;

  TKlasse2 = class(TObject)
    // auch viele Variablen, Funktionen, Prozeduren und so ...
    fKlasse1: PKlasse1;
    constructor Create(Klasse1: PKlasse1);
  end;

constructor TKlasse2.Create(Klasse1: PKlasse1);
begin
  //...
  fKlasse1:=Klasse1;
end;

zusammenfalten · markieren

Delphi-Quellcode:

type
  TForm1=class(TForm)
    //...
    Klasse1:TKlasse1;
    Klasse2:TKlasse2;
    //...
  end;

  // ...
  Variable2:=TKlasse2.Create(@Klasse1);
  // ...
  Variable1:=TKlasse1.Create;

Das Problem ist offensichtlich: Sollte Variable1 * zerstört werden **, funktioniert das Objekt der Klasse2 nicht mehr. Das fällt einem irgendwann garantiert nochmal auf die Füße.
Um das zu vermeiden, könnte man ein Interface erstellen, das Variable1 * kapselt und wegen der Referenzzählung erst zerstört wird, wenn das Objekt der Klasse2 auch verstört ist ***.

Zusammenfassend: Es es möglich, aber schön ist es nicht.

* Also die Referenz auf das Objekt der Klasse1.
** Z.B. weil es eine lokale Variable war oder das enthaltende Objekt (-> Form1) zerstört wurde.
*** Wohlgemerkt: das Objekt der Klasse1 kann da schon längst zerstört sein

Zitat von grl:

Jetzt kann ich natürlich die Sache so umbauen, daß die Klasse2 immer vorher erzeugt wird - aber das ist im aktuellen Fall erstens nicht schön und zweitens interessiert mich, ob ich wirklich auf'm Schlauch steh oder ob das irgendwie geht...

Wenn du magst, kannst du ja noch mal genauer beschreiben, warum das im aktuellen Fall unschön ist. Vielleicht gibt es noch eine schönere Lösung.

Spontan fällt mir so etwas ein (schnell heruntergetippt, das geht mit Sicherheit auch eleganter, funktionieren sollte es aber):

zusammenfalten · markieren

Delphi-Quellcode:

type
  TKlasse2 = class;

  TKlasse1 = class
  private
    FOwner: TKlasse2;
    procedure SetOwner(const Value: TKlasse2);
  public
    constructor Create(AOwner: TKlasse2);
    destructor Destroy; override;
    property Owner: TKlasse2 read FOwner write SetOwner;
  end;

  TKlasse2 = class
  private
    FKlasse1: TKlasse1;
  public
    constructor Create(AKlasse1: TKlasse1);
    property Klasse1: TKlasse1 read FKlasse1 write FKlasse1;
  end;

{ TKlasse2 }

constructor TKlasse2.Create(AKlasse1: TKlasse1);
begin
  inherited Create;
  FKlasse1 := AKlasse1;
end;

{ TKlasse1 }

constructor TKlasse1.Create(AOwner: TKlasse2);
begin
  inherited Create;
  FOwner := AOwner;
end;

destructor TKlasse1.Destroy;
begin
  Owner := nil;
  inherited;
end;

procedure TKlasse1.SetOwner(const Value: TKlasse2);
begin
  if Assigned(FOwner) then
    FOwner.Klasse1 := nil;
  FOwner := Value;
end;

Das Blöde ist dabei halt, dass sich die Klassen gegenseitig kennen müssen, unschön, gebe ich zu.

Zitat von grl:

Unter Umständen wird das Objekt aber erst nach dieser Übergabe erzeugt

Dann darfst du das Objekt nicht mit dem Konstruktor sondern nur über ein Property oder eine Methode übergeben!
Die Idee mit der Objektreferenz ist ein NO-GO.

Danke für die Antworten.

Die Geschichte ist mittlerweile anders gelöst, so daß die div. Fallen die da auftreten könnten weg sind und das ganze einfach eleganter ist.

Trotzdem wollte ich wissen, was ich da vermurkst hab - es war wohl einfach schon ein bischen spät gestern.

Danke
Luggi

Zitat von grl:

Trotzdem wollte ich wissen, was ich da vermurkst hab - es war wohl einfach schon ein bischen spät gestern.

Zitat:

markieren

Delphi-Quellcode:

  Klasse2:=TKlasse2.Create(Klasse1);
<...>
  Klasse1:=TKlasse1.Create;

Es wird der Inhalt in der Variable Klasse1 kopiert, also die Referenz darin. (TKlasse2.Create(Klasse1); bzw. fKlasse1:=Klasse1; )
Später tauschst du den Inhalt dieser Variable aus (Klasse1:=... )
und wunderst dich darüber, daß in der alten Kopie was anderes drinsteht?



Lösung:

markieren

Delphi-Quellcode:

Klasse1:=TKlasse1.Create;
Klasse2:=TKlasse2.Create(Klasse1);

oder eben die Objektreferenz erst dann übergeben, wenn sie existiert. (via Prozedur/Funktion oder Property, wie bereits genannt)