sorry für den blöden Titel, das Problem ist bissi schwer knapp zu beschreiben.
Also, ich hab einen SceneManager, der die Erzeugung/Benutzung/Löschung von Objekten übernimmt. Die Objekte müssen eine Subklasse von ManualObject sein.
Jedes dieser Objekte basiert auf einem Mesh.

Sagen wir ich habe so eine Klasse namens Circle geschrieben:

class Box : public ManualObject { 
public:
   Box(string name, Mesh* mesh) { ... }
... };

und jetzt würde ich gerne die Erzeugung/Speicherung und Löschung vom SceneManager übernehmen lassen. Ich hätte also irgendwie gerne sowas ("Pseudocode"):

// Aufruf: In meinem Beispiel soll createManualObject() ein Box* zurückliefern
ManualObject* box = sceneManager->createManualObject("Box", "meineBox", "BoxMesh");

ManualObject* SceneManager::createManualObject(string type, string name, string mesh) {
   Mesh* m = lade Mesh namens mesh
   Erzeuge von ManualObject abgeleitete Klasse, in unserem Fall also ein Box*
   Box* obj = new Box(name, mesh);

   mManualObjectMap[name] = obj; // Scene Manager verwaltet ereugte Objekte
   return obj;

Der Code geht natürlich nicht. Das Problem ist Zeile 7; ich weiß beim Schreiben des SceneManagers ja nicht, welche Klassen die Anwender mal schreiben werden. Hat wer irgend eine Idee, wie man das implementieren könnte, dass mein SceneManager beliebige von ManualObject abgeleitete Klassen erzeugen (und speichern) kann?

Edit:

So irgendwie könnte das gehen. Nicht getestet, und mal eben so hingehackt.

typedef ManualObject* (*CreatorFunction)(std::string const&, std::string const&);

typedef std::map<std::string, CreatorFunction> CreationFunctions;

void SceneManager::registerCreator(std::string const& type, CreatorFunction function)
{
    //m_creatorFunctions ist eine Instanz von CreationFunctions und Member von SceneManager
    CreationFunctions::const_iterator it = m_creatorFunctions.find(type);
    if(it != m_creatorFunctions.end() )
    {
       throw SchonRegistriert;
    }
    m_creatorFunctions[type] = function;
}

ManualObject* SceneManager::createManualObject(std::string const& type, std::string const& name, std::string const& mesh)
{
    CreationFunctions::const_iterator it = m_creatorFunctions.find(type);
    if(it == m_creatorFunctions.end() )
    {
        throw GibtEsNicht;
    }
    ManualObject * obj = (*it)(name, mesh);
    mManualObjectMap[name] = obj;
    return obj;
}

//vom Benutzer definiert

class Box : public ManualObject
{
public:
    Box(std::string const& name, std::string const& mesh);
    //...
    static ManualObject* create(std::string const& name, std::string const& mesh)
    {
        return new Box(name, mesh);
    }
}

//dann später:
sceneManager->registerCreator("Box", Box::create);

//...

ManualObject * obj = sceneManager->createManualObject("Box", "MyBox", "TheMesh");

int main() {
#ifdef MOTIF
   factory = new MotifFactory;
#else // WINDOWS
   factory = new WindowsFactory;
#endif
   Widget* w = factory->create_button();
   w->draw();
   display_window_one();
   display_window_two();
}

Eine MotifFactory liefert bei create_button() zb einen MotifButton* usw.

Mein SceneManager ist so eine Art Factory, aber ich will definitiv NICHT mehrere SceneManager haben. Außerdem waren in allen Beispielen, die ich zu dem Factory Pattern gefunden habe, die Typen bereits bekannt. Sprich ein MotifFactory::create_button() liefert immer einen MotifButton* usw. Bei mir sind die Subklassen von ManualObject zum Zeitpunkt wenn ich die Methode createManualObject() schreibe ja NICHT bekannt.
Wären da vielleicht Templates eine Möglichkeit?

Wenn ich dann noch

static ManualObject* createBox(std::string const& name, std::string const& mesh) {
return new Box(name, mesh);
 }

pure virtual mache und nach ManualObject verschiebe, dann müssen die konkreten Subklassen so eine "Erzeugerfunktion" implementieren.

Ist dein Code eigentlich noch das Pattern "Abstract Factory Pattern"?

Ich denke ich werde deine Lösung nehmen, aber nur zur Vollständigkeit: Ginge auch eine Lösung mit Templates? Also irgendwie sowas:

template<class SubClassOfManualObject>
SubClassOfManualObject* SceneManager::createManualObject(std::string const& name, std::string const& mesh) {

   SubClassOfManualObject* obj = new SubClassOfManualObject(name, mesh);
   mManualObjectMap[name] = obj; // Scene Manager verwaltet ereugte Objekte
   return obj;
}

?

...

Es ist doch später egal, ob es Box , Circle oder sonstwas ist.
Der Zugriff erfolgt über ManualObject . Deshalb brauchst Du kein Template. Außerdem wäre es schlecht, wenn die erzeugende Funktion virtuell wäre. Dann brächtest Du nämlich ein erst Objekt das von ManualObject abgeleitet wurde, um die Objekte zu erzeugen.
Und ja, das ist eine Variante vom Factory Pattern.

Vielen Dank für deinen Code Tachyon. Das gefällt mir schon ziemlich gut.

Wenn ich dann noch

static ManualObject* createBox(std::string const& name, std::string const& mesh) {
return new Box(name, mesh);
 }

pure virtual mache und nach ManualObject verschiebe, dann müssen die konkreten Subklassen so eine "Erzeugerfunktion" implementieren.

Dann müsstest du um ein Objekt zu erzeugen aber im Programmcode createBox als Methode von einem anderen ManualObject aufrufen - was hieße, dass ein Objekt das nächste erzeugt. Das ist vermutlich nicht wirklich sinnvoll (zumal dann noch das Problem besteht, wie man das erse Objekt erzeugt).

Ich denke ich werde deine Lösung nehmen, aber nur zur Vollständigkeit: Ginge auch eine Lösung mit Templates? Also irgendwie sowas:

template<class SubClassOfManualObject>
SubClassOfManualObject* SceneManager::createManualObject(std::string const& name, std::string const& mesh) {

   SubClassOfManualObject* obj = new SubClassOfManualObject(name, mesh);
   mManualObjectMap[name] = obj; // Scene Manager verwaltet ereugte Objekte
   return obj;
}

?

Dafür müsstest du im Code bereits wissen von welchem Typ das zu erzeugende Objekt ist, um den richtigen Templateparameter mitgeben zu können. Das macht die ganze Factory-Methode sinnfrei, weil du dann genausogut direkt den Ctor aufrufen könntest.

Vielen Dank für die schnelle Hilfe euch beiden!