/*
Ich habe eine Template Basisklasse Base, die eine pure virtual Funktion fun()
bereitstellt. Der Templateparameter soll mit den Basistypen wie
bool, float, int, char, usw. instanziiert werden.
*/
template <typename T>
class Base {
	virtual ~Base() {}
	virtual void fun(T v) = 0;
};
/*
Von dieser Basisklasse base werden eine Reihe von weiteren Klassen abgeleitet,
eine von ihnen ist Derived_1.
In Derived_1 sollen einige Funktionen wie auch die virtuelle Funktion fun()
unterschiedliche Implementierungen für Gleitkomma- und Integerzahlen haben.
Hierzu habe ich eine Klasse TypeInfo erstellt, die über ein statisches Feld
die entsprechende Art des Typs zurückliefert.
*/
typedef enum TypeKind {
	FLOATING_TYPE,
	INTEGRAL_TYPE,
} TypeKind_t;

#include <limits>
template <typename T>
class TypeInfo {
	static const TypeKind_t typeKind =
		std::numeric_limits<T>::is_integer ? INTEGRAL_TYPE
		                                   : FLOATING_TYPE;
};
/*
Nun zu dem eigentlichen Problem:
Wie schreibe ich nun am besten unterschiedliche Implementierungen von fun() für
die verschiedenen Typarten.

Ich habe an folgende Möglichkeiten gedacht, von denen jedoch keine mit g++ 4.xx
kompiliert:

a) Verwendung einer Template Funktion:
*/
template <typename T>
class Derived_1a : public Base<T> {
	template <TypeKind_t kind> void fun(T v);
	void fun(T v);
};

template <typename T>
template <>
void Derived_1a<T>::fun<FLOATING_TYPE>(T v) {
	// ...
}

template <typename T>
void Derived_1a<T>::fun(T v) {
	fun<TypeInfo::is_integer<T> >(v);
}

/*
b) Verwendung einer eingebetteten Hilfsklasse:
*/
template <typename T>
class Derived_1b : public Base<T> {
	template <TypeKind_t kind>
	class TypeDep {
		void fun(T v);
	} typeDep<TypeInfo::typeKind<T> >;

	void fun(T v);
};

template <typename T>
template <>
void Derived_1b<T>::TypeDep<FLOATING_TYPE>::fun(T v) {
	// ...
}

template <typename T>
void Derived_1b<T>::fun(T v) {
	typeDep.fun(v);
}

Ich hoffe ich konnte das Problem verständlich darstellen.
Ich würde mich sehr über Eure Hilfe freuen.

Vielen Dank, Florian

Wenn ich das richtig verstanden habe. Es könnten also auch 2 oder mehr unterschiedliche Implementierungen für double geben???

erst mal muss du dann Derived_1a von Base ableiten.
Wenn die einzelnen abgeleiteten Klassen unterschiedliche Implementierungen
haben dann mußt du die entsprechende nur instanziieren.

Ach Mist, so meinte ich das auch. Ich habs geändert.

Dann kannst du auch gleich virtual void fun() schreiben ohne den Typ T.

Wenn ich das richtig verstanden habe. Es könnten also auch 2 oder mehr unterschiedliche Implementierungen für double geben???

Es gibt halt 15 verschiedene Basisdatentypen, die ich nicht alle einzelnd spezialisieren wollte. Deswegen hat dieser Template-Meta-Programming Umweg.

dann brauchst du aber nur ein template. Da stopft man seine Typen rein.
Dafür ist ein Template ja da. Wenn dann z.B. die Ausgabe hinsichtlich der
Genauigkeit oder der Formatierung anders sein soll, dann würde ich das über Parameter machen, die ich einstellen kann oder intelligente Funktionen.

Nein, Parameter sind keine Option für mich, da das das Interface verschandelt. Außerdem ist es sinnvoll nur den Code zu generieren, der auch tatsächlich benötigt wird. Einige Funktionen gibt es für die jeweils andere Datentyp-Art auch gar nicht.

#include <limits>
#include <iostream>

using namespace std;

typedef enum TypeKind {
	FLOATING_TYPE,
	INTEGRAL_TYPE,
} TypeKind_t;

template <typename T>
class TypeInfo {
public:
	static const TypeKind_t typeKind =
		std::numeric_limits<T>::is_integer ? INTEGRAL_TYPE
		                                   : FLOATING_TYPE;
};

// ************************************************************************** //

template <typename T>
class Base {
public:
	virtual ~Base() {}
	virtual void fun(T v) = 0;
};

// ************************************************************************** //

template <typename T, TypeKind TK>
class DerivedTypeDependant : public Base<T> {
public:
	void fun(T v);
};

template <typename T>
class DerivedTypeDependant<T, FLOATING_TYPE> {
public:
	void fun(T v) {
		cout << "floating version: " << v << endl;
	};
};

template <typename T>
class DerivedTypeDependant<T, INTEGRAL_TYPE> {
public:
	void fun(T v) {
		cout << "integral version: " << v << endl;
	};
};

// ************************************************************************** //

template <typename T>
class Derived : public DerivedTypeDependant<T, TypeInfo<T>::typeKind > {
};

// ************************************************************************** //

int main() {
	Derived<float> fo;
	fo.fun(4.4);
	Derived<int> io;
	io.fun(4);
}

Danke für die Hilfe!