klassenverschachtelung, andere lösung als implentierung wie in der cpp

gibts hierfür eine lösung ausser die impletierung im stil klasse::methode zu definieren? wenn man das so schreibt gibts ja compiler fehler.

class B; // bringt nicht viel, da foob nicht bekannt ist

class A
{
private:
	B b;

public:
	void fooa()
	{
		b.foob();
	}
};

class B
{
private:
	A a;

public:
	void foob()
	{
		a.fooa();
	}
};

denn ich hab aber keine lust sowas hier zu schreiben:

class B; // reicht hier aus

class A
{
private:
	B b;
public:
	void fooa();
};

class B
{
private:
	A a;

public:
	void foob();
};

void A::fooa()
{
b.foob();
}

void B::fob()
{
a.fooa();
}

falls jemand eine lösung weiß, wäre ich dankbar
gute abend noch.

camper

wer zirkuläre abhängigkeiten hat, muss eben leiden

akari

Hallo

verbinde die einzelnen Klassen über Pointer anstatt konkreten Instanzen miteinander, dann reichen die Forward Declarations.

bis bald
akari

akari schrieb:

Hallo

verbinde die einzelnen Klassen über Pointer anstatt konkreten Instanzen miteinander, dann reichen die Forward Declarations.

bis bald
akari

Hier der ungefaire Aufbau meiner Anwendung:

class Object
{
// ..
};

namespace physic
{
	class World;

	class Body
	{
	private:
		World* _world; // pointer to the world, to which the body belongs to

	public:
		Body(Object* obj)
		{
			// ...
		}

	public:
		virtual void addForce(int forcex, int forcey)
		{
			//...

			// hier brauch ich aber z.b. die methode getSize von World
			// um zu gucken ob der Body aus der Reichweite der World ist etc.
			// hier bekomm ich nun aber:
			// error C2027: Verwendung des undefinierten Typs "physic::World"
			// error C2227: Links von "->getSize" muss sich ein Zeiger auf Klassen-/Struktur-/Union-/generischen Typ befinden.
			if(_world->getSize() != 0)
			{
			}
			//...
		}
	};

	class World
	{
	private:
		std::vector<Body*> _body_vector;

	public:
		// ctor & dtor usw.

	public:
		virtual void addBody(Object* obj)
		{
			// und hier brauch ich den konstruktor von Body
			_body_vector.push_back(new Body(obj));
		}
	};
}

Ich nehme mal an es gibt keine Lösung wie ich sie mir erhoffe, oder?

Ich sollte vielleicht noch erwähnen, dass getSize natürlich auch definiert ist.

akari

Hallo

in deinem Ausszug ist nicht die Aufteilung in Header/Implementation ersichtlich. Denn das geht so

// Datei1.h
class Object
{
...
};

// Datei1.cpp
...

// Datei2.cpp
#include "Datei1.h"

namespace physic
{
    class World;

    class Body
    {
    private:
        World* _world; // pointer to the world, to which the body belongs to

    public:
        Body(Object* obj);

    public:
        virtual void addForce(int forcex, int forcey);

        Body(Object* obj);

   };
 }

// Datei2.cpp
#include "Datei2.h"
#include "Datei3.h"

namespace physics
{
  void Body::addForce(int forcex, int forcey)
  {
    if(_world->getSize() != 0) // hier kann World frei benutzt werden
    {
    }
  }
}

// Datei3.h
#include "Datei1.h"

namespace Physics
{

  class Body;

  class World
  {
    private:
        std::vector<Body*> _body_vector;

    public:
        // ctor & dtor usw.

    public:
        virtual void addBody(Object* obj);
    };
}

// Datei3.cpp

#include "Datei3.h"
#include "Datei2.h"

namespace Physics
{

  void World::addBody(Object* obj)
  {
    _body_vector.push_back(new Body(obj)); // Hier kann Body frei benutzt werden
  }

}

/Edit : Offenbar ist aber das genau das was du nicht wolltest... warum eigentlich? Headerdatein sind nun mal nur für die Defintion der nach außen hin sichtbaren Schnittstelle zuständig. Warum willst du die Implementation unbedingt in die Headerdatei verlegen? Ansonsten gibt es für dein Problem keine Andere Lösung, da auch Compiler streng von oben nach unten arbeiten und alle Definitionen eben auch in dieser Reihenfolge bereit stehen müßen.

bis bald
akari

akari schrieb:

/Edit : Offenbar ist aber das genau das was du nicht wolltest... warum eigentlich? Headerdatein sind nun mal nur für die Defintion der nach außen hin sichtbaren Schnittstelle zuständig. Warum willst du die Implementation unbedingt in die Headerdatei verlegen? Ansonsten gibt es für dein Problem keine Andere Lösung, da auch Compiler streng von oben nach unten arbeiten und alle Definitionen eben auch in dieser Reihenfolge bereit stehen müßen.

bis bald
akari

Vielen Dank für deine Antwort.
Ich wollte meine kleine Klassenzusammenstellung zwar am liebsten so halten, dass ich weder .lib Dateien brauch noch .cpp's zu meinem Projekt hinzufügen muss, aber dann werde ich mich wohl dran gewöhnen müssen