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

[himitsu]

Zu c) :

Man benötigt nichtmal die virtuellen/abstrakten Methoden,
denn spätestens in der Implementation kann man ja die richtigen Units einbinden
und auch frühestens da würde man auch die Methoden benötigen und könnte dann da via Typecast

Delphi-Quellcode:

TClass2(BaseClass2)   {oder}   (BaseClass2 as TClass2)

an die richtigen Methoden rankommen.

Delphi-Quellcode:

Unit Common;
interface

type
  TBaseClass1 = class
  end;
  
  TBaseClass2 = class
  end;
  
implementation
end.

Unit Unit1;
interface
uses Common;

type
  TClass1 = class (TBaseClass1)
  private
    FClass2: TBaseClass2;
  public
    procedure Foo1; 
  end;
  
implementation
uses Unit2;

end.

////////////////////////////////////////

Unit Unit2;
interface
uses Common;

type
  TClass2 = class (TBaseClass2)
  private
    FClass1: TBaseClass1;
  public
    procedure Foo2;
  end;
  
implementation
uses Unit1;

end.

oder (Unit1 nochmal)

Delphi-Quellcode:

Unit Unit1;
interface
uses Common, Unit2;

type
  TClass1 = class (TBaseClass1)
  private
    FClass2: TBaseClass2;  // oder direkt TClass2
  public
    procedure Foo1; 
  end;
  
implementation

end.

[TOC]

Hi!

Oh, vielen Dank. Wenn das wirklich so funktioniert sollte ich das mal umschreiben!

Das mit dem Code sehe ich ein, hier mal etwas realer Code. Dann ist vielleicht auch klarer wodurch diese Abhängigkeiten entstehen:

Delphi-Quellcode:

unit NeuronNetwork;

interface

Uses Windows, Forms, Types, StdCtrls, ExtCtrls, SysUtils, Graphics, Classes, Math;

Type
  TNetColors = (colBG, colHintBG, colHintBorder, colReady, colTriggered, colSleeping,
                colAccumulate, colForget, colMemory);

  TTextPos = (tpLeft, tpRight, tpTop, tpBottom);

  TNeuronClass = (ncHardLimit, ncPWLinear);

  TNeuronType = (ntAccumulate, ntForget, ntMemory);

  TCalculation = (cnLinear, cnQuadratic, cnNegQuad, cnPosQuad);

  TNeuroTransmitter = (ntBias, ntPositive, ntNegative, ntPosPWL, ntNegPWL,
                       ntThreshold, ntIntensify, ntExtenuate,
                       ntPulseUp, ntPulseDown, ntClear, ntSleep, ntAwake);

  TPanelType = (ptTriggered, ptSleeping, ptCounter);

  TSynapse = Class;
  TNetwork = Class;

  PNeuron = ^TNeuron;
  TNeuron = Class(TObject)
  Private
    FOutputs, FInputs: TList;
    FCaption: String;
    FTextPos: TTextPos;
    FCanvas: TCanvas;
    FNeuronFont, FTextFont: TFont;
    FNeuronClass: TNeuronClass;
    FNeuronType: TNeuronType;
    FNetwork: TNetwork;
    FXP, FYP, FFontHeight, FRadius, FBorderWidth: Integer;
    FRange, FMin, FMax, FAngel, FOrgThreshold, FThreshold, FPositive, FNegative, FPosDelta,
    FRX, FRY, FBias, FPWL, FNegDelta: Double;
    FPulses, FPulsing, FDelay, FDelaying, FSleep, FSleeping: Cardinal;
    FFocused, FTriggered: Boolean;
    FCalculation: TCalculation;
    FTag, FEnum: Integer;
    FTagString: String;
  Protected
    Function  GetOutputs: Cardinal;
    Function  GetInputs: Cardinal;
    Procedure SetFocus(Focused: Boolean);
    Function  GetSynapse(Index: Cardinal): TSynapse;
    Procedure SetDelay(Value: Cardinal);
    Procedure AddInput(Synapse: TSynapse);
  Public
    Constructor Create(Network: TNetwork; Canvas: TCanvas; NeuronClass: TNeuronClass; NeuronType: TNeuronType; Calculation: TCalculation; Threshold: Double; Pulses, Sleep: Cardinal; XP, YP, Enum: Integer);
    Destructor  Destroy; OverRide;
    Procedure Clear;
    Function  Calculate: Boolean;
    Function  AddSynapse(DstNeuron: TNeuron; Transmitter: TNeuroTransmitter; Power: Double): TSynapse;
    Procedure SubSynapse(Synapse: TSynapse);
    Procedure DeleteSynapse(Index: Cardinal);
    Procedure Input(Synapse: TSynapse);
    Procedure Output;
    Procedure SetGraphicParams(FontHeight, NeuronRadius, NeuronBorderWidth: Cardinal);
    Procedure SetPosition(XP, YP: Integer);
    Procedure SetText(TextPos: TTextPos; Caption: String);
    Procedure SetMinMax(Min, Max: Double);
    Procedure SetDelayDelta(NegDelta, PosDelta: Double; Delay: Cardinal);
    Procedure SetFonts(NeuronFont, TextFont: TFont);
    Procedure Paint;
    Procedure SetRasterXY(RX, RY: Double);

    Property Caption: String read FCaption write FCaption;
    Property TextPos: TTextPos read FTextPos write FTextPos;
    Property NeuronClass: TNeuronClass read FNeuronClass;
    Property NeuronType: TNeuronType read FNeuronType;
    Property Delay: Cardinal read FDelay write SetDelay;
    Property PosDelta: Double read FPosDelta;
    Property NegDelta: Double read FNegDelta;
    Property OrgThreshold: Double Read FOrgThreshold;
    Property Calculation: TCalculation read FCalculation;
    Property Synapse[Index: Cardinal]: TSynapse read GetSynapse;
    Property Outputs: Cardinal read GetOutputs;
    Property Inputs: Cardinal read GetInputs;
    Property Triggered: Boolean read FTriggered;
    Property Sleeping: Cardinal read FSleeping;
    Property Tag: Integer read FTag write FTag;
    Property TagString: String read FTagString write FTagString;
    Property XPos: Integer read FXP write FXP;
    Property YPos: Integer read FYP write FYP;
    Property Focused: Boolean read FFocused write SetFocus;
    Property Number: Integer read FEnum;
    Property Angel: Double read FAngel write FAngel;
    Property Min: Double read FMin write FMin;
    Property Max: Double read FMax write FMax;
    Property Range: Double read FRange;
    Property NeuronFont: TFont read FNeuronFont write FNeuronFont;
    Property TextFont: TFont read FTextFont write FTextFont;
  End;

  PSynapse = ^TSynapse;
  TSynapse = Class(TObject)
  Private
    FSrcNeuron, FDstNeuron: TNeuron;
    FTransmitter: TNeuroTransmitter;
    FPower, FWeight: Double;
    FXP, FYP: Integer;
  Public
    Constructor Create(SrcNeuron, DstNeuron: TNeuron; Transmitter: TNeuroTransmitter; Power, Weight: Double);
    Destructor  Destroy; Override;
    Property SrcNeuron: TNeuron read FSrcNeuron write FSrcNeuron;
    Property DstNeuron: TNeuron read FDstNeuron write FDstNeuron;
    Property Transmitter: TNeuroTransmitter read FTransmitter write FTransmitter;
    Property Power: Double read FPower write FPower;
    Property Weight: Double read FWeight write FWeight;
    Property XPos: Integer read FXP write FXP;
    Property YPos: Integer read FYP write FYP;
  End;

  PConnection = ^TConnection;
  TConnection = Class(TObject)
  Private
    FNeuron: TNeuron;
    FSynapse: TSynapse;
    FXP, FYP: Integer;
    FSelfSynapse: Boolean;
  Public
    Constructor Create(Neuron: TNeuron; Synapse: TSynapse);
    Destructor  Destroy; Override;
    Property XPos: Integer read FXP write FXP;
    Property YPos: Integer read FYP write FYP;
    Property Neuron: TNeuron Read FNeuron write FNeuron;
    Property Synapse: TSynapse read FSynapse write FSynapse;
    Property SelfSynapse: Boolean read FSelfSynapse write FSelfSynapse;
  End;

  PDestPanel= ^TDestPanel;
  TDestPanel = Class(TPanel)
  Private
    FPanelType: TPanelType;
    FCaptionOn, FCaptionOff: String;
    FNeuron1, FNeuron2: TNeuron;
    FCount: Integer;
  Public
    Constructor Create(PanelType: TPanelType; CaptionOn, CaptionOff: String; Neuron1, Neuron2: TNeuron); Reintroduce;
    Destructor  Destroy; Override;

    Procedure IncCounter;
    Procedure DecCounter;
    Procedure ClearCounter;

    Property CaptionOff: String read FCaptionOff;
    Property CaptionOn: String read FCaptionOn;
    Property Neuron1: TNeuron read FNeuron1;
    Property Neuron2: TNeuron read FNeuron2;
    Property PanelType: TPanelType read FPanelType;
    Property Count: Integer Read FCount write FCount;
  End;

  PNetwork = ^TNetwork;
  TNetwork = Class(TObject)
    Private
      FScrollBox: TScrollBox;
      FSrcButtons, FDstPanels: TPanel;
      FBitmap, FHintMap: TBitmap;
      FCanvas: TCanvas;
      FButtons, FPanels, FConnections, FNeurons, FSynapses: TList;
      FHintNeuron, FFocused: TNeuron;
      FTimer, FWidth, FHeight, FRaster: Cardinal;
      FShowHint, FBuilding, FPaintConnections, FPaintSynapses: Boolean;
      FHintX, FHintY, FLastHint, FFontHeight, FRadius, FBorderWidth, FSynapseRadius,
      FXPos, FYPos, FRasterOffset: Integer;
      FHintFlag, FClockFlag: Boolean;
      FHintStrings: TStringList;
      FNeuronFont, FTextFont: TFont;
    Protected
      Function  GetNeurons: Cardinal;
      Function  GetNeuron(Index: Cardinal): TNeuron;
      Procedure ChangePaintSynapses(Value: Boolean);
      Procedure ChangePaintConnections(Value: Boolean);
      Procedure PaintSynapses;
      Procedure SourceButtonClick(Sender: TObject);
      Procedure UpdatePanels;
      Procedure SetShowHint(Value: Boolean);
      Procedure ClearConnections;
      Procedure CalculateConnections;
    Public
      Constructor Create(ScrollBox: TScrollBox; SrcButtons, DstPanels: TPanel);
      Destructor  Destroy; OverRide;

      Procedure SetGraphicParams(Canvas: TCanvas; FontHeight, Width, Height, Raster, NeuronRadius, NeuronBorderWidth, SynapseRadius: Cardinal; NeuronFont: TFont; TextFont: TFont = Nil; HintFont: TFont = Nil);
      Procedure Calculate;
      Procedure Transmit;
      Procedure Clear;
      Function  AddNeuron(RX, RY: Double; NeuronClass: TNeuronClass; NeuronType: TNeuronType; Calculation: TCalculation; Threshold: Double; Pulses, Sleep: Cardinal): TNeuron;
      Procedure SubNeuron(Neuron: TNeuron);
      Procedure DeleteNeuron(Index: Cardinal);
      Function  AddSynapse(DstNeuron: TNeuron; Transmitter: TNeuroTransmitter; Power: Double): TSynapse;
      Procedure SubSynapse(Synapse: TSynapse);
      Procedure DeleteSynapse(Index: Cardinal);
      Procedure SetPos(XPos, YPos: Integer);
      Function  IndexOf(Neuron: TNeuron): Integer;
      Function  FindNeuron(Tag: Integer): TNeuron;
      Function  FindNeuronString(TagString: String): TNeuron;
      Procedure ClearFocus;
      Procedure Paint;
      Procedure BeginBuild;
      Procedure EndBuild;
      Procedure PageSize(Width, Height: Integer);
      Procedure CheckMouseHint;

      Procedure CreateSourceButton(Caption, Hint: String; Synapse: TSynapse);
      Procedure CreateDestPanel(PanelType: TPanelType; CaptionOn, CaptionOff, Hint: String; Neuron1, Neuron2: TNeuron);

      Property  Neuron[Index: Cardinal]: TNeuron read GetNeuron;
      Property  Neurons: Cardinal read GetNeurons;
      Property  Focused: TNeuron write FFocused;
      Property  DrawSynapses: Boolean read FPaintSynapses write ChangePaintSynapses;
      Property  DrawConnections: Boolean read FPaintConnections write ChangePaintConnections;
      Property  ShowHint: Boolean read FShowHint write SetShowHint;
      Property  XPos: Integer read FXpos write FXpos;
      Property  YPos: Integer read FYPos write FYPos;
  End;

Const
  // Clear Types
  ctAll = 0.0;
  ctThreshold = 1.0;
  ctData = 2.0;

 NeuroTransmitter: Array[TNeuroTransmitter] of String = ('Bias', 'Positive', 'Negative',
                                                         'Positive PWL', 'Negative PWL',
                                                         'Threshold', 'Intensify', 'Extenuate',
                                                         'PulseUp', 'PulseDown', 'Clear',
                                                         'Sleep', 'Awake');

 NeuronClass: Array[TNeuronClass] of String = ('Hard Limit', 'Piecewise Linear');

 NeuronType: Array[TNeuronType] of String = ('Accumulate', 'Forget', 'Memory');

 Calculation: Array[TCalculation] of String = ('Linear', 'Quadratic', 'Negativ Quadratic', 'Positive Quadratic');

Var
  Network: TNetwork;
  NetColors: Array[TNetColors] of TColor;

implementation
...

Ok, das ist alleine mal der Interface-Teil. Der Code für all die Prozeduren und Funktionen kommt hinzu- unhandlich ohne Ende :oops: !

Grüße von TOC!

[TOC]

Hi!

Ja, aber wenn ich in Unit1 sage "Uses unit2" und in Unit 2 "Uses Unit1" dann motzt Delphi7 herum und sagt ein überkreuzender Bezug zweier Units sei nit erlaubt :cry: !

Grüße von TOC!

[mkinzler]

Einmal im Interface und einmal im Implemnentierungsteil, dann geht es

[TOC]

Hi!

Zitat:

Zitat von mkinzler

Einmal im Interface und einmal im Implemnentierungsteil, dann geht es

Echt? Ok, das scheint mir dann die beste Lösung. Das werde ich mal versuchen. Vielen Dank!

Grüße von TOC!

[himitsu]

Zitat:

Zitat von TOC

Echt?

Ja.

Der Grund:
Units welche im Interface eingebunden werden, werden immer vor der einbeindenden Unit initialisiert (Finalisierung andersrum)

Alle Units, welche in der Implementation eingebunden werden, können auch später initialisiert werden.

Tja, und wenn sich nun 2 Units gegenseitig im Interface einbinden wöllten, dann muß ja Jede vor der Anderen initialisiert werden, was ja wohl nicht geht, denn es kann ja nur einen Ersten geben.

[TOC]

Zitat:

Zitat von himitsu

Zitat:

Zitat von TOC

Echt?

Ja.

Der Grunde:
Units welche im Interface eingebunden werden, werden immer vor der einbeindenden Unit initialisiert (Finalisierung andersrum)

Alle Units, welche in der Implementation eingebunden werden, können auch später initialisiert werden.

Tja, und wenn sich nun 2 Units gegenseitig im Interface einbinden wöllten, dann muß ja Jede vor der Anderen initialisiert werden, was ja wohl nicht geht, denn es kann ja nur einen Ersten geben.

Ok Super :thumb: Erklärung! Das wußte ich WIRKLICH noch nicht! Ich habe es gerade getestet und ein kleines Programm mit 2 Units geschrieben die siche gegenseitig im Implementaion-Teil aufrufen. Und von Form1/Unit1 konnte ich beide Units problemlos einbinden.
Ich denke das war ein Super Tip!

Grüße von TOC!