Templates und statische Funktionen

Hallo miteinander,

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

CStoll

Erstmal am Rande: Was genau soll denn der 'typedef' in der Calculation-Klasse darstellen? Du kannst mit typedef nur Typen definieren und keine Funktionen/Methoden.

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>();

das typedef schreibt nur die signatur der serialisierungsmethode vor, die dem konstruktur der calculation klasse übergeben wird. damit kann vom anderer selbst bestimmt werden, wie die daten eines objekts im xml dargestellt werden sollen. meines wissens ist eine automatische serialisierung in c++ ja nicht möglich, selbst nicht auf objektbasis. So etwas ist mir eher aus dem java umfeld bekannt.

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

CStoll

Da wundert mich aber, daß der typedef durch den Compiler kommt - eine Funktion ist kein Typ (ein Funktionspointer schon - und afaik müsstest du auch einen Funktionszeiger dort verwenden: typedef strind (*serialize)(const T&); .

hustbaer

Eine Funktion ist kein Typ, hat aber einen Typ.
Typedefs auf Funktionstypen funktionieren wunderbar, und sind AFAIK auch legales C++.

camper

Ausdrücke mit dem Typ einer Funktion entstehen eigentliche bei fast jedem Funktionsaufruf. Ähnlich wie Arrays zerfallen sie allerdings beim geringsten Anzeichen von Gefahr in Pointer auf Funktionen - lediglich bei Anwendung der Adressoperators & und des Funktionsaufrufoperators () ist das nicht der Fall.

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.