#pragma once
#include "BBB.h"
class CBBB;
class CAAA{
public:
	CAAA(void);

	void AAA_func(){
		CBBB o;
		o.BBB_func();
	}
	~CAAA(void);
};

#include "AAA.h"
class CAAA;
class CBBB{
public:
	CBBB(void);

	void BBB_func(){
		CAAA o;
		o.AAA_func();
	}

	~CBBB(void);
};

1. Interface und Impl. trennen (H und CPP)
2. Mit Pointer od. Referenzen arbeiten (falls als Member od. Funk. Arg.) und Vorwärtsdekl.

Simon

das kann gar nicht funktionieren, denn CAAA muss ein CBBB erzeugen, damit sie selbst instanziert werden kann. CBBB muss aber ein CAAA erzeugen und CAAA wieder ein CBBB.... wie man erkennt, endet das in endloser rekursion.

(AAA.h)

struct CAAA{
   void AAA_func();
};

(AAA.cpp)

#include "AAA.h"
#include "BBB.h"
void CAAA::AAA_func() {
   CBBB o;
   o.BBB_func();
}

(BBB.h)

struct CBBB{
   void BBB_func(){
	CAAA o;
	o.AAA_func();
   }
}

(BBB.cpp)

#include "BBB.h"
#include "AAA.h"
void CBBB::BBB_func(){
   CAAA o;
   o.AAA_func();
}

... geht doch tadellos.
Aufrufen würde ich das Ganze natürlich nicht - aber "Erzeugen" geht.

Gruß,

Simon2.

P.S.: Diese c-Präfixnotation finde ich nicht besonders glücklich...

oh, stimmt. die objekte sind ja gar nicht teil der jeweils anderen klasse sondern werden nur "temporär" in einer methode erzeugt.

Macht ja nix. Ich hatte es auch spontan mißverstanden....
Der Titel und die Angewohnheit, sowieso Deklaration und Implementierung zu trennen, legten das auch etwas näher (finde ich jedenfalls) ....

Gruß,

Simon2.