man verzeih mir den Titel aber mir ist nichts passenderes eingefallen.

Problematik:
Ich habe ein Klassentemplate a la:

template<typename T>
class Generic
{
private:
   Scene* ptr_scene; //The scene this object resides in..
   foo()
   {
      ptr_scene->do_something();
   }
}

Und eine Klasse Scene (die eine Szene verwaltet, sprich jede Menge verschiedener Objekttypen...Generic ist nur ein Beispiel):

#include "generic.h"

class Scene
{
 private:
   Generic<double>* obj;
}

Und da komm ich in eine Bedrouille. Dadurch dass ich nicht "scene.h" in der generic.h einbeziehen kann, weil ja generic.h schon umgekehrt in scene.h einbezogen ist, erhalte ich jede Menge compiler fehler, verständlicherweise.

Bei einer normalen Klasse könnte ich scene.h in der Quelldatei einspeisen und es gäbe keine probleme. Wie mache ich das aber mit einem Klassentemplate? Vor allem weil ich so viele habe und nicht einfach in einer Datei layern kann.

Das Scene Objekt soll als "Verwaltungseinheit" gesehen werden, sprich es verwaltet (alloziiert etc.) und fungiert als Schnittstelle zwischen den Szeneobjekten.

Bin für Hilfe aber auch Ideen dankbar
Gruß

class Scene; // Jetzt weiss der Compiler, dass Scene eine Klasse ist.
             // Scene darf ab jetzt als Pointer und Referenz verwendet 
             // werden, jedoch nicht als normales Objekt, da die Grösse
             // noch unbekannt ist.

template<typename T>
class Generic
{
private:
   Scene* ptr_scene; //The scene this object resides in..
   foo()
   {
      ptr_scene->do_something();
   }
}

vielen dank erstmal für die Antwort. Jedoch habe ich das schon gemacht! Dennoch schreit er.

Jedoch habe ich die Forward-Deklaration in der Basisklasse gemacht (sprich, Generic ist im tatsächlichen Projekt nochmal von iGeneric abgeleitet...ja das hätte ich ruhig mal erwähnen können..ändert die Problematik?).

Alle abgeleiteten Klassen greifen auf ptr_scene zu indem sie die Protected member funktion GetScene() aufrufen (ich könnte auch ptr_scene direkt als protected member "sichtbar" machen..). Sieht also eher so aus.

class Scene; 

class iGeneric
{
private:
   Scene* ptr_scene; //The scene this object resides in..
protected:
   Scene* GetScene() { return ptr_scene; }
}

#include "iGeneric.h"

template<typename T>
class Generic : public iGeneric
{
private:
   foo()
   {
      GetScene()->do_something();
   }
}

Fehler ist durchweg: Verwendung des undefinierten Typs "Scene"...
hmm, oder sollte es mit der Forward-Deklaration dennoch gehen und ich habe folglich einen anderen Fehler irgendwo liegen?

/***** Geht nicht ******/
// header:
struct C {
  foo() { GetScene()->do_something(); }
  // Woher sollte der Compiler die Funktion do_something kennen?
}

/***** So geht's ******/
// header-datei:
struct C {
  void foo(); // Funktionen nur deklarieren
}

// code-datei
#include "Scene.h"
void C::foo() { GetScene()->do_something(); } // Jetzt ist Scene ganz bekannt.

In deinem ersten Code-Beispiel sehe ich keinen Fehler, das müsste so kompillieren.

wo meinst du denn kann ich in meinem Beispiel die scene.h einspeisen? und ist es auch valide die Funktionsdefinition des Klassentemplates erst in einer späteren Quelldatei zu definieren? Das dürfte doch gar nicht gehen oder? Sonst bestünde das Problem nicht wenn ich ne Quelldatei hätte wo ich die Templatedefinition schreiben könnte (ohne diese halt wiederum in die tempalte-datei einzuspeisen).

In deinem ersten Code-Beispiel sehe ich keinen Fehler, das müsste so kompillieren.

Aber da rufe ich ja auch ne funktion auf mit dem forward declared pointer von Scene?

Danke erstmal!