ich würde gern wissen, ob es möglich ist, eine Fabrikmethode als Klassentemplate zu realisieren. Ich stell mir das ungefähr so vor:

class IrgendeineKlasse : public FabrikKlasse<IrgendeineKlasse>
{

 /* Blah */
};

Ein neues Objekt würde man dann einfach so erstellen:

IrgendeineKlasse k = IrgendeineKlasse::erstelleNeuesObjekt();

Wie müsste die FrabrikKlasse aussehen, um sowas zu realiseren? Geht das überhaupt?

Ich danke Euch für jede Hilfe

#ifndef FACTORYCLASS_H
#define FACTORYCLASS_H

#include <list>

template <class T>
class FactoryClass
{
public:
    FactoryClass()
    {
        m_factoryInstances.push_back(static_cast<T*>(this));
    }

    virtual ~FactoryClass()
    {
        m_factoryInstances.erase(std::remove(m_factoryInstances.begin(), m_factoryInstances.end(), static_cast<T*>(this)));
    }

    static int getInstanceCount()
    {
        return m_factoryInstances.size();
    }

    static std::list< T* > getInstances()
    {
        return m_factoryInstances;
    }

private:
    static std::list< T* > m_factoryInstances;
};

template <class T>
std::list<T*> FactoryClass<T>::m_factoryInstances;

#endif // FACTORYCLASS_H

Echt praktisch sowas, oder?

Das sieht mir nicht sehr fest nach eine Factory aus..

Wie erstelle ich da denn jetzt ein neues Objekt?
Wie füge ich da etwas in diese ominöse Liste ein?
Warum hält die Fabrik eine Liste von T, wo du dann aber doch die Fabrik selbst rein packst?

Ich brauchte nur einen Instanz-Zähler, die Liste enthält eben diese Instanzen und registrieren tun sich die Objekte selbst über den Konstruktor.

Warum virtueller Destruktor? Willst du die Objekte abgeleiteter Klassen jemals als FactoryClass<T>* oder FactoryClass<T>& ansprechen? Falls nicht, zwing nicht alle erbenden Klassen dazu, polymorph zu werden.

Ausserdem geht das Entfernen aus der Liste etwas einfacher:

m_factoryInstances.remove(static_cast<T*>(this));