ich habe folgendes Problem, dass ich bislang noch nicht lösen konnte:

Eine Factory-Klasse soll den Zugriff auf neue Objekt bzw. die Erzeugung dieser erleichtern. Dabei liegt folgender Sachverhalt vor: Es existiert eine abstrakte Klasse RESULT von welcher zahlreiche Klassen erben. Diese Klassen heißen z.B. RADAR2D oder CALCULATION. Letztere bietet die Möglichkeit Objekte beliebigen Typs aufzunehmen. Dazu habe ich die Klasse mit Hilfe von Templates realisiert.

Mein tatsächliches Problem ist nun Folgendes: In der Factory sind statische Funktionen wie etwa createRadar2d() zufinden. Gleiches möchte ich auch für die Calculation-Klasse anbieten. Allerdings weis ich nicht wie ich der Funktion createCalculation() den Zieltyp übergeben kann, welcher später den Typ der Objekte im Calculation Objekt bestimmt.

Hier noch ein paar Ausschnitte aus dem Quellcode.

Klasse Result:

class Result{

private:

	int mIdentifier;

	static bool initialized;

public:

	int getIdentifier() const;

	virtual XmlElement* serializeToXML() const = 0;

	Result();
	virtual ~Result();

};

Klasse Radar2d:

class Radar2d : public Result {

public:

	void addDetection(const Detection2d&);

	virtual XmlElement* serializeToXML() const;

	Radar2d();
	virtual ~Radar2d();

};

Klasse Calculation:

template<class T> class Calculation : public Result {

public:

	typedef std::string serialize(const T&);

	void addData(const T&);

	virtual XmlElement* serializeToXML() const;

	Calculation(const serialize*);
	virtual ~Calculation();	

};

Klasse ResultCreatorFactory:

class ResultCreatorFactory
{
public:

	static Calculation<int>* createCalculation();  // hier muss wohl etwas anderes stehen
	static Radar2d* createRadar2d();

	/*ResultCreatorFactory();
	virtual ~ResultCreatorFactory();*/
};

Ich habe keine Ahnung ob mein Konstrukt in C++ überhaupt realisiert werden kann, aber vielleicht hat ja jmd. eine idee, wie ich einen ausweg aus dieser misere finden kann.

mfG

der C++ nope

Dann: Klar kannst du eine statische Methode auch als Template definieren:

template<typename T>
static Calculation<T>* createCalculation();

Aber da die Funktion keine Parameter hat, kann der Compiler bei der Anwendung nicht selber ermitteln, welche Spezialisierung er braucht. Also mußt du das selber angeben:

Calculation<int>* pcal = ResultCreatorFactory::creatCalculation<int>();

Vielen dank schon mal für die hilfestellung. ich werde mich gleich einmal daran versuchen.

typedefs für Funktionstypen sind legal und können benutzt werden, um Funktionen zu deklarieren, nicht aber, um sie zu definieren.

typedef int foo(int);
foo bar1; // Deklariert die Funktion int bar1(int)
struct X
{
    foo bar2; // Deklariert die nicht-statische Funktion int X::bar2(int); - Der Typ von bar2 ist eigentlich nicht foo... aber gewisse Inkonsistenzen gehören bei C++ dazu,
              // es gibt allerdings auch keine typedefs für nicht-statische Memberfunktionen
// aber nicht:
    const foo bar4; // illegal, ist nicht equivalent zu int X::bar3(int) const; - Comeau bringt hier nur eine Warnung, es ist aber nicht zulässig [8.3.5/4]
};

Funktionstypen sind niemals cv-qualifiziert, deshalb ist die Deklaration

Calculation(const serialize*);

feherhaft.