Heyho,

also: Ich habe eine Unit mit einer Klasse. Diese besitzt die Property einer Klasse, die ich in einer anderen Unit untergebracht habe. Nun möchte ich in der "zweiten" Klasse in einer Procedure auf eine Property einer Instanz der "ersten" Klasse zugreifen. Wie tue ich das? U.a. gibt es dann irgendwie Problem mit zirkuläre Referenz... Bsp. (was ich möchte):

"UnitBaum":

markieren

Delphi-Quellcode:

uses
  UnitAst
type TBaum=class(TObject)
  public
    property EinAst: TAst;
    property Baum_hat_Schaden: boolean;
...

"UnitAst":

zusammenfalten · markieren

Delphi-Quellcode:

uses
  UnitBaum // ???
type TAst=class(TObject)
  public
    procedure Ast_abbrechen;
...
  procedure TAst.Ast_abbrechen;
  begin
    Breche_Ast_ab;
    MyBaum.Baum_hat_Schaden := true;
  end;
...

Und in meiner MainUnit create ich ein Object von TBaum (MyBaum), sodass ich dann aus der MainUnit heraus nur "Ast_abbrechen" aufrufen brauche, und nicht noch zusätzlich für ein Object von TBaum extra "MyBaum.Baum_hat_Schaden := true" aufrufen muss. Ist praktisch ein Ereignis auf "Ast_abbrechen" ???

Ist das einigermaßen verständlich, wo ich nicht so durchsehe? Da ich selber grad nich so durchsehe, kanns auch sehr unverständlich sein

Hallo,

für Dein Problem gibt es eigentlich nur drei Möglichkeiten.
Erstens: Du packst alles in eine Unit.
Zweitens: Du deklarierst das Ganze so:

zusammenfalten · markieren

Delphi-Quellcode:

unit
  UnitAst;

type TAst=class(TObject)
  public
    MyBaum: TObject;
    procedure Ast_abbrechen;
...

implementation

uses
  UnitBaum;

  procedure TAst.Ast_abbrechen;
  begin
    Breche_Ast_ab;
    TBaum(MyBaum).Baum_hat_Schaden := true;
  end;

Drittens: Du entwirfst Deine Objekte als Interfaces und deklarierst beide in einer Datei (das läuft dann auf eine Art Header-File hinaus: Deklaration und Implementierung in verschiedenen Dateien). So kannst Du die beiden Objekte in getrennten Unit belassen und greifst nur noch über die Deklaration darauf zu.

Gruß
xaromz

Die gegenseite Einbindung könntest du damit lösen das du die beiden Klassen in eine Unit implementierst. Dabei musst du nicht zwangsläufig auch die Methoden in der gleichen Unit haben. Du könntest für beide Klassen (die in verschiedenen Units sind) jeweils eine Basisklasse machen mit abstrakten Methoden und diese Methoden überschreibst du dann in den entsprechenden einzelnen Units:
Unitx:

zusammenfalten · markieren

Delphi-Quellcode:

[...]
type
  TBasisKlasse2 = class;

  TBasisKlasse1 = class(TObject)
  public
    RefToClass2: TBasisKlasse2;
    procedure MethodeVonKlasse1; abstract;
  end;

  TBasisKlasse2 = class(TObject)
  public
    RefToClass1: TBasisKlasse1;
    procedure MethodeVonKlasse2; abstract;
  end;

Unit Klasse1:

zusammenfalten · markieren

Delphi-Quellcode:

[...]
uses Unitx;
[...]
type
  TKlasse1 = class(TBasisKlasse1)
  public
    procedure MethodeVonKlasse1; override;
  end;
[...]
procedure TKlasse1.MethodeVonKlasse1;
begin
  if RefToClass2 <> nil then
    RefToClass2.MethodeVonKlasse2;
end;

Unit Klasse2:

zusammenfalten · markieren

Delphi-Quellcode:

[...]
uses Unitx;
[...]
type
  TKlasse2 = class(TBasisKlasse2)
  public
    procedure MethodeVonKlasse2; override;
  end;
[...]
procedure TKlasse2.MethodeVonKlasse1;
begin
  if RefToClass1 <> nil then
    RefToClass1.MethodeVonKlasse1;
end;

Durch das deklarieren der abstracten Methoden können also die einzelnen Klassen auch auf die Methoden der anderen Klassen zugreifen. Um die Übersichtlichkeit zu wahren kannst du natürlich auch die "unitX2" in 2 units aufspalten welche dann jeweils nur eine Basisklasse enthält.

Der Einfachheit halber hab ich jetzt alles in eine Unit geschrieben, da die Methoden/Eigenschaften von der zweiten Klasse eh nicht so zahlreich sind.