//B.h

#include "A.h"

class B{

  A* m_p;
  B(A *p): m_p(p){
    m_p->funk();  //<--- Problem 
  }

};

//A.h

#include "B.h"

class A{

  B *p;

  A(){
   p= new B(this);
  }
  void funk(){}

};

in A.h kann er B nich fidnen, wenn ich bspw. in A: B->funk() aufrufe,
auch wenn ich B Forward- Deklariere?
Was mach ich nun?

*genauer hinschaut*
Das Problem ist, daß beide Ctoren die jeweils komplette Klassendefinition benötigen (A braucht die Größe von B für den new-Aufruf, B muß die Methoden von A kennen). Also mußt du mindestens eine der Ctor-Definitionen aus der Klassendefinition rausziehen:

class A;

class B
{
  A* m_p;
  B(A *p);
};

#include "A.h"

inline B::B(A*p)
 : m_p(p)
{
  m_p->funk();
}

reicht es wenn ich ne neue funktion mache, die in Cstro afurufe, und dann die entsprechende funktion in der neuen aufurfe?

Kannst du den Satz bitte mal auf Deutsch wiederholen?

(Nur zur Erklärung des Problems: Forward Deklarationen sagen dem Compiler nur, daß es die angegebene Klasse gibt - das reicht aus umd Pointer oder Referenzen darauf anzulegen, aber mehr auch nicht. Wenn der Compiler wissen muß, wie die Klasse aufgebaut ist (z.B. um Methoden aufzurufen oder Instanzen anzulegen), benötigt er die komplette Definition.)

es reicht doch wenn ich

#include "B.h"
class A{
..
.
.
B *p= new B(this);

};

weul in beim erzeugen von ner B instaznt kommt eben der Fehler...

(btw, nutzt du eigentlich Include Guards?)

PS: Und ich hoffe, diese Anweisung steht im Inneren einer Methode von A.

jetzt kommt fehler C2514: klasse hat keine konstukoren..

es reicht doch wenn ich

#include "B.h"
class A{
..
.
.
B *p= new B(this);

};

weul in beim erzeugen von ner B instaznt kommt eben der Fehler...

dasd idzt dovch volkmmen klar ein mas hnse reiht eignetluc...

grußs,
simn2

dasd idzt dovch volkmmen klar ein mas hnse reiht eignetluc...

Eine Klasse:

// header
#pragma once

// CProcPaths command target
#include "ProcGraph.h"

//class CProcGraph;

//extern class CProcGraph;

class CProcPaths : public CObject{

	CProcGraph* m;
public:
	inline CProcPaths(CProcGraph *p);// : m(p) {};
	CProcPaths(){}

	virtual ~CProcPaths();
};
//CPP

#include "ProcPaths.h"

//class CProcGraph;

// CProcPaths

CProcPaths::CProcPaths(CProcGraph *p) : m(p){

	int k= p->GetSize();

}

Die Andere klassse:

#include "ProcPaths.h"

class CProcGraph : public CObject{

	DECLARE_DYNAMIC(CProcGraph)

public:
.
.
.
.
	CProcPaths *m_pPaths;
public:
//Konstruktor

	CProcGraph(int iNodes=0) : m_iSize(iNodes){

		//Checken
		ASSERT(iNodes>0);

		//Knoten Laden
		LoadNodes(iNodes);

		//Prozesspfade erzeugen
	//	this->m_pPathes= new CProcPaths(this,0,iNodes);
		m_pPaths= new CProcPaths(this);

	}

.
.
.
};

die beide klassen sind gegenseitig abhängig

@Simon: Was gab's denn gestern abend zu feiern

Wenn ich aus der CProcPaths klasse die CProcGraph zeiger und rausenhem dann läufts.. die gegenseitige abhöängig keit macht ihm woh zu schaffen...

der compiler weis wohl nich was zuerst da war das huhn oder das ei...

der compiler weis wohl nich was zuerst da war das huhn oder das ei...

Genau das ist das hüpfende Komma. Pack mal in die ProcPath.h die Forward-Deklaration und in die ProcPath.cpp das #include "ProcGraph.h" , dann sollte die zyklische Abhängigkeit eigentlich aufgedröselt sein.

...
@Simon: Was gab's denn gestern abend zu feiern

Was heißt hier gestern ? Heute ist doch "free-orthography-day" (oder wie Boris sagen würde "fre.orphpganü-da")

Gruß,

Simon2.

ich verfehle nur tasten, und meine leertasten sind nich oft syncron mit der wort trennung!!