Zirkuläre Referenz von zwei Klassen vermeiden

[Chaosente]

Also cih hab zwei klassen, und jede braucht die andere für sich selbst:

Klasse 1:

Delphi-Quellcode:

type
  TKKPlayer = class
  private
  FName: string;
  FColor: TColor;
  FID: integer;
  FScore: integer;
  FHandleList: array of TIDShape;
  FHeartBeat: TTimer;
  FAI: boolean;
  procedure OnHeartBeat(Sender: TObject);
  public
  constructor Create(name: string; Color: TColor; ID: integer; AI: boolean);
  property PlayerName: string read FName write FName;
  property PlayerColor: TColor read FColor write FColor;
  Property PlayerID: integer read FID write FID;
  property PlayerScore: integer read FScore write FScore;
  property Heartbeat: TTimer read FHeartbeat write FHeartbeat;
  property AI: boolean read FAI write FAI;
  procedure AddToHandle(a:TIDShape);
  end;

Klasse 2:

Delphi-Quellcode:

type
  TIDShape = class(TShape)
  private
    FYID: integer;
    FXID: integer;
    FOwned: boolean;
    FOwnedBy: TKKPlayer;
    FValue: integer;
  public
    property YID: integer read FYID write FYID;
    property XID: integer read FXID write FXID;
    property Owned: boolean read FOwned write FOwned;
    property OwnedBy: TKKPlayer read FOwnedby write FOwnedBy;
    property Value: integer read FValue write FValue;
  end;

Ich hab nur leider keine ahnung wie ich es so arangieren kann, dass ich es nciht zirkulär aufbaue... hat jemand ne ahnung wie ich das machen kann?

[luka]

Versuch es einmal hiermit:

Delphi-Quellcode:

TIDShape = class;

Den Rest findest Du in der Delphi-Hilfe, da solltest Du unbedingt einmal reinschauen. :wink:

[3_of_8]

Liegen die Klassen in der gleichen Unit?

Wenn ja, geht das so:

Delphi-Quellcode:

TClass1 = class;

TClass2 = class
protected
  class1: TClass1;
end;

TClass1 = class
protected
  class2: TClass2;
end;

[Chaosente]

Wenn ich einfach

Delphi-Quellcode:

type TIDShape = class;

diesen teil vor meine code setze, dann sagt er

[Fehler] KKObjects.pas(8): E2086 Typ 'TIDShape' ist nicht vollständig definiert

[mkinzler]

Zeig mal deine Deklaration

[Chaosente]

Hier:

Delphi-Quellcode:

type TIDShape = class;

type
  TKKPlayer = class
  private
  FName: string;
  FColor: TColor;
  FID: integer;
  FScore: integer;
  FHandleList: array of TIDShape;
  FHeartBeat: TTimer;
  FAI: boolean;
  procedure OnHeartBeat(Sender: TObject);
  public
  constructor Create(name: string; Color: TColor; ID: integer; AI: boolean);
  property PlayerName: string read FName write FName;
  property PlayerColor: TColor read FColor write FColor;
  Property PlayerID: integer read FID write FID;
  property PlayerScore: integer read FScore write FScore;
  property Heartbeat: TTimer read FHeartbeat write FHeartbeat;
  property AI: boolean read FAI write FAI;
  procedure AddToHandle(a:TIDShape);
  end;

type
  TIDShape = class(TShape)
  private
    FYID: integer;
    FXID: integer;
    FOwned: boolean;
    FOwnedBy: TKKPlayer;
    FValue: integer;
  public
    property YID: integer read FYID write FYID;
    property XID: integer read FXID write FXID;
    property Owned: boolean read FOwned write FOwned;
    property OwnedBy: TKKPlayer read FOwnedby write FOwnedBy;
    property Value: integer read FValue write FValue;
  end;

[mkinzler]

Lass mal die ganzen überflüssigen Types weg:
type

Delphi-Quellcode:

  TIDShape = class;

  TKKPlayer = class
 ...
  end;

  TIDShape = class(TShape) 
...

[Chaosente]

hui warum sind die überflüssig?

geht nciht deklaration erwartet...

[mkinzler]

Weil sich das type anders wie typedef in C in Delphi auf den Abschnitt und nicht auf die folgende Deklaration bezieht

[DGL-luke]

alle "type"s bis auf das erste bitte ersatzlos streichen.

[Chaosente]

Amen,

dankeschön wieder was dazu gelernt

[Jens Schumann]

Hallo,
es kann auch der Fall eintreten, dass die Klassen in getrennten units stehen müssen.
Hier kenne ich nur eine Lösung über eine "Zwischenunit" und Polymorphie.

Die Klassen TClass2 und TClass4 sind in getrennten unit deklariert.
in unit3 in der jeweils ein Vorfahre für TClass2 (TClass31) und TClass4 (TClass32)
deklariert

Delphi-Quellcode:

unit Unit3;

interface

Type

  TClass31 = class(TObject)
  private
  public
  end;

  TClass32 = class(TObject)
  private
  public
  end;

implementation

end.

In unit2 wird jetzt unit3 eingebunden und FClass als TClass32 deklariert
jedoch als TClass4 erzeugt.

Delphi-Quellcode:

unit Unit2;

interface

uses unit3;

Type

  TClass2 = class(TClass31)
  private
    FClass : TClass32;
  public
    constructor Create;
    destructor  Destroy; override;
  end;

implementation

uses unit4;

{ TClass2 }

constructor TClass2.Create;
begin
  inherited Create;
  FClass:=TClass4.Create;
end;

destructor TClass2.Destroy;
begin
  FClass.Free;
  inherited Destroy;
end;

end.

In unit4 wird ebenfalls unit3 eingebunden FClass als TClass31 deklariert
jedoch als TClass2 erzeugt.

Delphi-Quellcode:

unit Unit4;

interface

uses unit3;

Type

  TClass4 = class(TClass32)
  private
    FClass : TClass31;
  public
    constructor Create;
    destructor  Destroy; override;
  end;


implementation

uses unit2;

{ TClass4 }

constructor TClass4.Create;
begin
  inherited Create;
  FClass:=TClass2.Create;
end;

destructor TClass4.Destroy;
begin
  FClass.Free;
  inherited Destroy;
end;

end.

[Oxmyx]

Ich hab das, wenn es sich nicht vermeiden ließ, meist so gelöst:

Unit1:

Delphi-Quellcode:

interface

uses Unit2;

type
  KlasseA = class
  ...
    b: KlasseB;
  end;

Unit2:

Delphi-Quellcode:

interface

type
  KlasseB = class
  ...
    a: TObject;
  end;

implementation

uses
  Unit1;

...und dann eben in KlasseB jedes Mal casten, wenn "a" aufgerufen werden soll.

Ist nicht schön, aber auch nicht so schlimm.