Unit-übergreifende Vorwärtsdeklaration von Klassen?

[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!