ich würde gerne folgendes machen. Eine Klasse soll eine Mehtode implementieren, in der ich ein Objekt mit den Standardkonstruktor oder mit einem x-beliebigen mit x-Parametern aufrufen kann. Mein Ansatz:

// in einer Klasse
template<class X>
X* newObject(X* (*constructor) () = null)
{
    X* obj = this->currentBlock.getRaw<X > (); // roher Speicher aus einem Block

    if (constructor == null)
        return new (obj) X();
    else
        return new (obj) constructor;
};

Kann ich das mit einem Template lösen, ala

template<class X, ??? LangerNamezurUbersicht>
X* newObject(X* (*constructor) (LangerNamezurUbersicht) = null)
{

Oder bin ich da auf dem falschen Dampfer? Wahrscheinlich ist es wieder eine Kleinigkeit und ich währe froh, wenn jemand mir das mitteilen könnte

Gruß
Thomas

struct my_creator
{
	template <class T>
	static T* create ()
	{
		//
		return new T;
	}
};

struct your_creator
{
	template <class T>
	static T* create ()
	{
		//
		return new T;
	}
};

class foo
{
public:
	template <class T, class creator>
	T* create ()
	{
		return creator::create<T>();
	}
};

int main ()
{
	foo f;
	f.create<int,my_creator> ();
	f.create<int,your_creator> ();
}

Eine andere Möglichkeit wäre es mit Funktionsobjekten zu arbeiten, wie es die Standardbibliothek ebenfalls häufig tut.

Was ich nun auch umgesetzt habe. Statische Strukturen schränken das Ganze stark ein

drakon schrieb:

Eine andere Möglichkeit wäre es mit Funktionsobjekten zu arbeiten, wie es die Standardbibliothek ebenfalls häufig tut.

Was ich nun auch umgesetzt habe. Statische Strukturen schränken das Ganze stark ein

Ist für Parameter sicher sinnvoller, ja.