Variablenübergabe zwischen zwei Units

[Stefan Hueg]

Hallo ihr DPler,

habe nun nach langer Pause wieder angefangen mit Delphi zu programmieren und stehe nun vor einem kleinen Verständnisproblem.
Folgendes Szenario: Ich habe 2 Units (beide gehören zu Formularen), Unit1 und Unit2. Unit1 gehört zum Hauptformular, Unit2 ist ein Unterformular. Nun wollte ich von Unit2 auf eine bestimmte Variable von Unit1 zugreifen, doch wie ging das normal? Nach Recherche im Forum ist mir dann wieder eingefallen dass die Variable im Interface-Teil deklariert werden muss um darauf zuzugreifen. Soweit so gut.

Nun das eigtl. Problem:
Unit2 soll auf die Variable von Unit1 zugreifen -> Unit1 muss in Unit2 eingebunden sein
Unit1 soll aber das Formular, zu dem Unit2 gehört, anzeigen (Form.Show) können -> Unit2 muss in Unit1 eingebunden sein.

Geht jedoch nicht, dann kommt irgend ein Zirkumdingensbumens ^^

Gibt es eine elegante Methode um das zu umgehen? Ich meine nicht sowas wie eine Prozedur wie "procedure UebertrageVariable(Variable: String);"

Sondern ob man den beidseitigen Zugriff, also das Form.Show, und den Zugriff auf die Variable elegant hinbekommt?

Nun schlagt mich nicht, schon lang her seit ich programmiert hab ^^

Vielen Dank im Vorraus,

Stefan

[leddl]

Schreib die Units - anstatt in den Interface-Teil - in den Uses-Teil der Units

[SirThornberry]

du musst unter implementation die andere Unit in die Uses einbinden (also nicht unter interface).

Delphi-Quellcode:

unit Unit1;

interface

uses
  //hier nicht

type
  TForm1 = class(TForm)
  [...]
  end;

implementation

uses
  unit2; //<= hier muss es hinn

in Unit2 das ganze genau umgekehrt (also anstelle von "unit1", "unit2" hinschreiben.

[leddl]

Meinte ich eigentlich Hab da wohl was durcheinandergebracht...

[Stefan Hueg]

Wow echt schnell die Antwort ^^
Werde ich mal ausprobieren, aber wo genau liegt der Unterschied (zum Verständnis) zwischen dem uses in der Unit und im Interface?

[Khabarakh]

Zitat von Stefan Hueg:

Gibt es eine elegante Methode um das zu umgehen?

Kann es nicht geben, weil schon dein Ziel unelegant ist . Du solltest immer auf eine einseitige Beziehung hinarbeiten, dann hast du auch keine Überkreuzberüge. Die Hauptform muss wohl die Unterform kennen, damit sie diese erstellen kann. Also könntest du die Variable entweder im Konstruktor übergeben oder - wenn dies erst irgendwann nach der Erstellung geschehen soll - per Event der Unterform die Hauptform höflich bitten, ihr gefälligst die Variable zu geben.
Mit beiden Methoden hat die Unterform keine Ahnung davon, welche Klasse denn nun überhaupt als Hauptform fungiert.

[edit]
Kuhl, 4 nichtexistente rote Kästen .

Zitat:

Werde ich mal ausprobieren, aber wo genau liegt der Unterschied (zum Verständnis) zwischen dem uses in der Unit und im Interface?

Der statische Delphi-Compiler grast zuerst alle Interfaces, dann alle Implementations ab. Der Kreuzüberzug ist also nach Interface 1 -> Interface 2 -> Implementation 1 aufgelöst.

[SirThornberry]

Achja, fällt mir grad erst auf.
Bitte verwende eine Titel der dein Problem beschreibt.

Der Unterschied würde mich auch interessieren. Also was Compilertechnich der Unterschied ist. Ich denk mal auf die Art und Weise soll einfach sichergestellt werden das 2 Declarationen nicht auf sich Gegenseitig verweisen. Allerdings ist dies ja wieder möglich wenn sich beide Klassen in einer Unit befinden. Von daher bischen komisch.

[Khabarakh]

Zitat von SirThornberry:

Der Unterschied würde mich auch interessieren. Also was Compilertechnich der Unterschied ist.

Der Compiler weigert sich einfach, zwei Interface/Implemenation-Abschnitte gleichzeitig zu parsen. Sie müssen immer in eine feste Reihenfolge gebracht werden.

Zitat:

Allerdings ist dies ja wieder möglich wenn sich beide Klassen in einer Unit befinden. Von daher bischen komisch.

Hab ich was verpasst ? Mit Delphi 6 geht das jedenfalls (noch) nicht:

Delphi-Quellcode:

TFoo = class
    bar: TBar;
  end;

  TBar = class
    foo: TFoo;
  end;

Oder meinst du im implementation-Abschnitt? Da ist es wegen oben beschriebener Trennung von Implementation und Interface möglich.

[Stefan Hueg]

Habe jetzt mal folgendes als Testprojekt angelegt:

Delphi-Quellcode:

unit Unit1;

interface

uses
  Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
  Dialogs, StdCtrls;

type
  TForm1 = class(TForm)
    Button1: TButton;
    procedure Button1Click(Sender: TObject);
    procedure FormCreate(Sender: TObject);
  private
    { Private declarations }
  public
    { Public declarations }
  end;

var
  Form1: TForm1;
  MSGs: TStringList;

implementation
  uses Unit2;

{$R *.dfm}

procedure TForm1.Button1Click(Sender: TObject);
begin
  Form2.Show;

end;

procedure TForm1.FormCreate(Sender: TObject);
begin
  MSGs := TStringList.Create;
  MSGs.Add('Test');
end;

end.

Und hier die 2. Unit

Delphi-Quellcode:

unit Unit2;

interface

uses
  Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
  Dialogs, StdCtrls;

type
  TForm2 = class(TForm)
    Button1: TButton;
    procedure Button1Click(Sender: TObject);
  private
    { Private declarations }
  public
    { Public declarations }
  end;

var
  Form2: TForm2;

implementation
  uses Unit1;

{$R *.dfm}

procedure TForm2.Button1Click(Sender: TObject);
begin
  ShowMessage(Unit1.MSGs.Strings[0]);

end;

end.

Funktioniert auch super so. Nun dazu aufbauend eine weitere Frage die sich mir nun stellt, wenn ich Form2 öfter benutze, also quasi als Status-Fenster wenn irgendwas geschieht, sollte man es dann immer mit Show/Hide aufrufen und "schließen" oder gleich den Konstruktor und Destruktor verwenden und jedes mal das Fenster neu erstellen? Ich glaub von der Sauberkeit her sollte Show/Hide besser klappen oder?

Ansonsten ist meine Frage beantwortet, danke Leute

[SirThornberry]

Bitte erstelle für eine neue Frage einen neuen Thread.
@Khabarakh: so wirds gemacht:

Delphi-Quellcode:

  TBar = class;

  TFoo = class 
    bar: TBar; 
  end; 

  TBar = class 
    foo: TFoo; 
  end;