ich weiss leider nicht genau, nach welchen Suchbegriffen ich suchen soll. Das Thema wurde sicherlich schon behandelt. Also sorry erst mal für den vermeintlichen repost.

Ausgangssituation:
Visual Studio 2005
CLR - Klassenbibliothek
Eine öffentliche Klasse main
Die Klasse main hat jetzt z.B. Methoden zur berechnung sagen wir mal des Kreisumfangs.
Die DLL hat noch ein Formular zur Eingabe und Ausgabe der Daten (Radius und Umfang)

Folgendes Problem:
Ich rufe aus main das Formular auf.
Ich möchte die Methode aus main im Formular zur Berechnung verwenden.
Dazu brauche ich ja eine Referenz auf das Objekt main.
Dazu muss ich das Formular ja schon mit der Refernez auf das Objekt main (this) als Parameter aufrufen.

Jetzt hab ich dann aber ein Problem mit den Header-Dateien:
Entweder ich include zu erst die Header-Datei für das Formular, dann ist main als Typ im Formular unbekannt -> Fehler, oder anderes herum, dann ist das Formular in main nicht bekannt -> Fehler.

Ich hoffe ich habe das jetzt so erklärt, dass Ihr wisst was ich meine.

Also auf den Punkt gebracht:
Was muss man machen, dass 2 Objeke gegenseitig Methoden aufrufen können; Ich muss ja eine Header Datei als erstes includen angeben.

Danke.

//Form.h

class Main;

class Form
{
public:
  void run(Main* pMain);
  ...
};

//Main.h

#include "Form.h"

class Main
{
public:
  void run()
  {
    Form theForm;
    theForm.run(this);
  }
};

(btw ist der Name "main" afaik für die Hauptfunktion eines Programmes reserviert - wenn du eine Klasse so benennst, könnte es Probleme geben)

Natürlich heißt die Methode nicht main, war nur ein Beispiel; Aber zugegeben ein ziemlich Blödes

funktioniert leider so nicht...

// TestForwardDeklaration.h

#pragma once

using namespace System;

namespace TestForwardDeklaration {

	public ref class Init
	{
	public:
		TestForwardDeklaration::Formular^ Form1;

		Init();
		void Message(String^ text);
	};
}

//TestForwardDeklaration.cpp
// Dies ist die Haupt-DLL.

#include "stdafx.h"
#include "Formular.h"
#include "TestForwardDeklaration.h"

TestForwardDeklaration::Init::Init() {
	Form1 = gcnew Formular(this);
}

void TestForwardDeklaration::Init::Message(String^ text) {
	MessageBox::Show(text);
}

//Fourmular.h
#pragma once

using namespace System;
using namespace System::ComponentModel;
using namespace System::Collections;
using namespace System::Windows::Forms;
using namespace System::Data;
using namespace System::Drawing;

namespace TestForwardDeklaration {

	//Forward Deklaration
	ref class Init;

	/// <summary>
	/// Zusammenfassung für Formular
	///
	/// Warnung: Wenn Sie den Namen dieser Klasse ändern, müssen Sie auch
	///          die Ressourcendateiname-Eigenschaft für das Tool zur Kompilierung verwalteter Ressourcen ändern,
	///          das allen RESX-Dateien zugewiesen ist, von denen diese Klasse abhängt.
	///          Anderenfalls können die Designer nicht korrekt mit den lokalisierten Ressourcen
	///          arbeiten, die diesem Formular zugewiesen sind.
	/// </summary>
	public ref class Formular : public System::Windows::Forms::Form
	{
	public:
		Formular(Init^ Parent)
		{
			InitializeComponent();
			//
			//TODO: Konstruktorcode hier hinzufügen.
			//
			Parent->Message("test");
		}
...

//Fourmular.cpp

#include "StdAfx.h"
#include "Formular.h"

Alle Anderen Dateien sind wie von VS2005 erstellt.

Fehler 1 error C2027: Verwendung des undefinierten Typs "TestForwardDeklaration::Init" c:\_intern\coding\projekte\testforwarddeklaration\testforwarddeklaration\Formular.h 34
Fehler 2 error C2227: Links von "->Message" muss sich ein Zeiger auf Klassen-/Struktur-/Union-/generischen Typ befinden. c:\_intern\coding\projekte\testforwarddeklaration\testforwarddeklaration\Formular.h 34

Liegt das am managed code? Oder hab ich da noch nen Anderen Fehler drin?

Wie sieht das dann in diesem Beipiel richtig aus?

MainObj -> erstellt Formular und gibt Refernz auf sich selbst mit.
Formular -> soll im Konstruktor auf eine Methode von MainObj zugreifen.

Ich verteh das Prinzip noch nicht ganz.

Es gibt da zwei Varianten:
Objekt2 wurde in Objekt1 erstellt und soll auf Mehtoden von Objekt1 zugreifen (wie oben)
Objekt1 und Objekt2 sind absolut unabhängig und bekommen während der Laufzeit die Refernz auf das jeweillig andere Objekt zugewiesen und können dann gegenseitig Methoden aufrufen.

//MainObj.h
class Formular;

class MainObj
{
public:
  Formular* form;
  void init();
  void run();
  void print(std::string test) {cout<<test<<endl;}
};

//MainObj.cpp
#include "MainObj.h"
#include "Formular.h"

void MainObj::init()
{
  form = new Formular(this);
}

void MainObj::run()
{
  form->calculate();
}

//Formular.h
class MainObj;
class Formular
{
  MainObj* parent;
public:
  Formular(MainObj* p);
  void calculate();
}

//Formular.cpp
#include "Formular.h"
#include "MainObj.h"

Formular::Formular(MainObj* p) : parent(p) {}

void Formular::calculate()
{
  parent->print("Dies ist ein Test");
}

Ich hab mir das jetzt so umgebaut:

// stdafx.h : Includedatei für Standardsystem-Includedateien
// oder häufig verwendete projektspezifische Includedateien,
// die nur in unregelmäßigen Abständen geändert werden.

#pragma once
#include "class1.h"

#include "form1.h"
#include "form2.h"

#include "maincode.h"

// stdafx.cpp
#include "stdafx.h"

namespace dll {

	// forward declaration
	// Libs
	ref class class1;
	// Forms
	ref class form1;
	ref class form2;
	// Main
	ref class maincode;
}

// maincode
#include "stdafx.h"

namespace dll {
	public ref class maincode {
            ...
        };
}

Die Namen sind natürlich beispielhaft zu verstehen.

Macht man das eigentlich prinzipiell so, oder nur nach Bedarf?

Aber...
Also wenn ich nen Formular anlege, dann schreibt das VS2005 ja standardmässig
#include "StdAfx.h" in die cpp-Datei des Formulars, bzw. in die cpp-Datei eines neuen Projekts.

Und aufgrund der Info in der "stdafx.h" bin ich mal davon ausgegangen, dass die Datei genau für so etwas da ist.

// stdafx.h : Includedatei für Standardsystem-Includedateien
// oder häufig verwendete projektspezifische Includedateien,
// die nur in unregelmäßigen Abständen geändert werden.

Hat eingetlich ganz gut funktioniert so. Aber man kann es ja genau so in die Dateien (.cpp/.h) des eigentlichen Codes packen.