Unit-übergreifende Vorwärtsdeklaration von Klassen?

[TOC]

Hi!

Ich habe folgendes Problem:

In einer Unit definiere ich drei Klassen die gegenseitig voneinander abhängig sind. Also Klasse 1 enthält einen Pointer auf Klasse 2, Klasse 2 enthält einen Pointer auf Klasse 1 und 3, und Klasse 3 enthält einen Pointer auf Klasse 1 und 2. Innerhalb einer Unit ist es nun kein Problem mit "TClassName = Class" eine Klasse vorwärts zu deklarieren um solche Strukturen zu ermöglichen.

Delphi-Quellcode:

Unit ;

Interface

Type
  TClass1 = Class;
  TClass3 = Class;

  TClass2 = Class(TObject)
  Privat
   FClass1: TClass1;
   FClass3: TClass3;
   ...
  End;

  TClass1 = Class(TObject)
  Privat
   FClass2: TClass2;
   ...
  End;

  TClass3 = Class(TObject)
  Privat
   FClass1: TClass1;
   FClass2: TClass2;
   ...
  End;

Mein Problem ist nun das meine Unit langsam unhandlich groß wird (schon über 1200 Zeilen), einfach dadurch das ich alle 3 Klassen in der selben Unit vereinen muss.
Gibt es auch eine Möglichkeit (in Delphi 7) Klassen unit-übergreifend vorwärts zu deklarieren, damit ich die drei Klassen jeweils in eine eigen Unit verlegen könnte?

Ich freue mich über jeden hilfreichen Tip!

Grüße von TOC!

[mkinzler]

Nein, da Delphi (noch) keine partielle Klassen kennt

[Teekeks]

du könntest die Deklaration der 3 Klassen in eine Unit packen (wie bisher) und die Implementation der Proceduren und funktionen in 3 .inc-Dateien aufteilen.

[TOC]

Hi!

Zitat:

Zitat von Teekeks

du könntest die Deklaration der 3 Klassen in eine Unit packen (wie bisher) und die Implementation der Proceduren und funktionen in 3 .inc-Dateien aufteilen.

Ah, danke für den Tip. Ich habe es gerade mal mit einer (kleinen) Klasse probiert. Ok, Delphi kompiliert das und der Code wäre sauber getrennt. Nur: Innerhalb der INC-Datei, selbst wenn ich sie mit dem Delphi-Editor öffne, funktioniert die automatische Code-Hilfe dummerweise nicht. Wenn ich die Code-Hilfe aufrufe behauptet der Compiler der Quelltext sei fehlerhaft und deshalb würde dies nicht gehen. Und das macht es natürlich recht schwierig an den 3 Units weiter zu arbeiten (sie sind ja auch noch nit fertig außer der Mini-Klasse-1 :x !

Grüße von TOC!

[Teekeks]

Hmmm, das wäre aber die einzige Möglichkeit die mir einfällt und unter Lazarus geht das auch ;)

[himitsu]

Zitat:

Zitat von mkinzler

Nein, da Delphi (noch) keine partielle Klassen kennt

Und da Vorwärtsdeklaration immer innerhalb des selben Type-Blocks stehen müssen.

2 Units = 2 getrennte Blöcke

[TOC]

Hi!

Zitat:

Zitat von Teekeks

Hmmm, das wäre aber die einzige Möglichkeit die mir einfällt und unter Lazarus geht das auch ;)

Vielleicht sollte ich mich mal intensiver mit Lazarus beschäftigen. Ist zwar OT aber mit D7 habe ich nur Probleme- der Editor stürzt zum Beispiel immer wieder ab und nimmt keine Tasten mehr an. Und dann muss ich alles speichern, Delphi beenden und mein Programm neu öffnen- es nervt. Die Code-Hilfe stürzt dauernd ab, das Hilfesystem ist mies und viele Variablen aus Windows-Funktionen sind schlicht falsch definiert (Cardinal anstatt Integer und so) und der symbolische Debugger macht auch Probleme...
Also, wenn ich ehrlich bin habe ich auf D7 schon fast kein Bock mehr... Ich bin mir nicht sicher ob ich mir ein moderneres Delphi besorgen oder ganz auf eine andere Sprache umsteigen sollte...

Grüße von TOC!

[khh]

Zitat:

Zitat von TOC

Hi!

Zitat:

Zitat von Teekeks

Hmmm, das wäre aber die einzige Möglichkeit die mir einfällt und unter Lazarus geht das auch ;)

Vielleicht sollte ich mich mal intensiver mit Lazarus beschäftigen.
Ich bin mir nicht sicher ob ich mir ein moderneres Delphi besorgen oder ganz auf eine andere Sprache umsteigen sollte...

Grüße von TOC!

OT: was spricht gegen Lazarus? Probiers doch einfach aus ;-)

[himitsu]

Ab Delphi 2006 :?: könnte man Einiges über RecordHelper lösen.

PS: Das mit den .inc hatte ich vor Jahren (ebenfalls noch zu meinen Delphi 7-Zeiten) mal versucht, aber das Debugging ist dort nicht das Wahre.


PSS: Dabei war die Delphi 7-OH doch mit eine der Besten ... vorallem wenn man sie z.B. mit der von Delphi 2006-2009 vergleicht.
Und ansonsten läuft Delphi 7 bei mir immernoch um längen besser, als z.B. Turbo Delphi.
(selbst jetzt, zu D2010-Zeiten, nutze ich es manchmal noch, denn es ist klein und extrem flink)

[Hawkeye219]

Hallo TOC,

zunächst solltest du versuchen, die Abhängigkeiten zwischen den Klassen so weit wie möglich aufzulösen. Je komplexer deine Applikation wird, desto schwieriger wird es mit dieser Struktur, Fehler zu finden und einzelne Klassen zu testen.

Falls du an der Struktur festhalten möchtest oder musst, gibt es folgende Möglichkeiten:

a) "weak" pointer - Bei der Definition werden die Verweise als TObject vereinbart, in der Implementierung sind dann Typecasts notwendig. Das Problem dabei ist, dass du die Typenprüfung des Compilers umgehst und sich sich auf diese Weise weitere Fehler einschleichen können.

b) Interfaces - Neben dem oft zu vernachlässigenden Performanceverlust können bei Kreuzreferenzen Memoryleaks auftreten. Wenn sich zwei Instanzen über Interface-Variablen gegenseitig referenzieren, kann keine der Instanzen automatisch freigegeben werden.

c) Abstrakte Klassen:

Delphi-Quellcode:

Unit Common;
interface

type
  TAbstractClass1 = class
  public
    procedure Foo1; virtual; abstract;
  end;
  
  TAbstractClass2 = class
  public
    procedure Foo2; virtual; abstract;
  end;
  
  TAbstractClass3 = class
  public
    procedure Foo3; virtual; abstract;
  end;

implementation
end.


Unit Unit1;
interface
uses Common;

type
  TClass1 = class (TAbstractClass1)
  private
    FClass2: TAbstractClass2;
  public
    procedure Foo1; override;
  end;
  
implementation
uses Unit2;  
end.


Unit Unit2;
interface
uses Common;

type
  TClass2 = class (TAbstractClass2)
  private
    FClass1: TAbstractClass1;
    FClass3: TAbstractClass3;
  public
    procedure Foo2; override;
  end;
  
implementation
uses Unit1, Unit3;  
end.


Unit Unit3;
interface
uses Common;

type
  TClass3 = class (TAbstractClass3)
  private
    FClass1: TAbstractClass1;
    FClass2: TAbstractClass2;
  public
    procedure Foo3; override;
  end;
  
implementation
uses Unit1, Unit2;  
end.

Man kann solche Strukturen auf die gezeigte Weise aufbrechen, ob es in deinem Fall aber die beste Lösung darstellt, ist aufgrund des gezeigten Quelltextes schwer zu beurteilen.

Gruß Hawkeye