# Vorwärtsdeklaration



## themonk (9. September 2009)

Hallo,
ich habe 2 Header Datein. Header A und B. In A rufe ich eine Funktion in B, B arbeitet dann und ruft zum schluss eine funktion in A auf aber wie kann ich das realisieren. Nur durch includen und namespace kann ich von A eine Funktion in B aufrufen aber nicht mehr umgekehrt.
So nun zu meinen Datein:
A.h

```
#ifndef __HEADER_B
#define __HEADER_B
class daten;
namespace projekttest{

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

	public ref class Form1 : public System::Windows::Forms::Form
	{
...
public: void textboxandern(String ^text)
       {
          button1->Text = "test";
        }
....

#endif
```
B.h

```
#ifndef __HEADER_H
#define __HEADER_H
class Form1;
namespace daten{
using namespace System;
using namespace projekttest;
ref class daten// ... blabla
{

public: daten(Form1^ form1)  //*1
        {
		
           // InitializeBlabla
           
           this->form1 = form1;          
        }

     String^    dat(String^ von)
        {
   	 

form1->textboxandern("tee");


		  return "nichts";
        }

private: Form1^ form1;
};
}#endif
```
Beide habe in in der .c++(main) includet.
Dann bekomme ich 27 Fehler der erste ist 
*1  =error C2872: 'Form1': Mehrdeutiges Symbol


----------



## Thomasio (9. September 2009)

Form1 wird in HEADER_H definiert und in HEADER_B gefüllt.
Includest du HEADER_B vor HEADER_H kommt also die "Vorwärts-Deklaration" erst hinterher.


----------



## themonk (9. September 2009)

Das verstehe ich leider nicht ganz


----------



## Thomasio (9. September 2009)

Das siehst du ganz deutlich, wenn du statt include den Inhalt des Headers in deine Main kopierst, denn effektiv bedeutet "include" nichts anderes.
Dann steht in deiner main


```
// include HEADER_B

class kassebutton;
namespace projekttest{

...

public ref class Form1 : public System::Windows::Forms::Form
	{
                            ...
                     }
}

// include HEADER_H

class Form1;
namespace daten{

...

}

// usw.
```


----------



## themonk (9. September 2009)

Es ist egal wie ich include es kommt immer der fehler.


----------



## Thomasio (10. September 2009)

Logisch, denn andersrum included steht in deiner main


```
// include HEADER_H

class Form1;
namespace daten{
using namespace System;
using namespace projekttest;

// usw

}

// include HEADER_B

class kassebutton;
namespace projekttest{

// ...

}
```

sprich du benutzt projekttest bevor du es definierst.

Du kannst einfach nicht Vorwärts-Deklarationen sonstwohin schreiben, und dann kreuz und quer includen, in der Hoffnung, dass irgendwie immer Deklaration vor erster Nutzung kommt.


----------



## deepthroat (10. September 2009)

Hi.

Das erste Problem: deine Vorwärtsdeklaration stimmt nicht mit der Definition deiner Klassen überein. Einen Referenz-Typ muss auch so deklariert werden:

```
ref class daten1;
```
Zu deiner Frage: solche zyklischen Abhängigkeiten sind schlechtes Design und sollten vermieden werden. Wenn du irgendwie andere Objekte benachrichtigen willst wenn eine Änderung eingetreten ist, dann benutze Delegaten suchen.

Grundsätzlich kann man so zyklische Abhängigkeiten in Headerdateien definieren:

```
#ifndef HEADER_A
#define HEADER_A

#include "header_b.hpp"

ref class XYZ {
  // ...
};

#else

ref class XYZ;

#endif // HEADER_A
```
Gruß


----------

