Одно простое решение - определить base шаблон класса, содержащий вещи, которые вы хотите специализировать, а затем вместо этого специализировать этот шаблон класса (в конце концов, это будет небольшой класс):
template<typename T>
struct printable
{
protected:
void print(const T & _t) { }
};
template<>
struct printable<double>
{
protected:
void print(const double & _t) { }
};
А потом на его основе:
template<typename T>
class MyClass : public printable<T>
{
typedef printable<T> base;
public:
MyClass(T t&):_t(t){}
~MyClass(){}
void print(){ base::print(_t); } //forward
private:
T _t;
};
Вам больше не нужно специализировать этот шаблон класса;сделайте его настолько большим, насколько вы хотите (и разумным).
Другой альтернативой является дизайн на основе политики , в котором вы передаете класс (ы) политики в качестве аргумента (ов) шаблонав шаблон вашего класса (называется host class).
Например,
//lets define few policy classes
struct cout_print_policy
{
template<typename T>
static void print(T const & data)
{
std::cout << "printing using cout = " << data << std::endl;
}
};
struct printf_print_policy
{
static void print(int data)
{
std::printf("printing int using printf = %d\n", data);
}
static void print(double data)
{
std::printf("printing double using printf = %f\n", data);
}
};
//now define the class template (called host class) that
//accepts policy as template argument
template<typename T, typename TPrintPolicy>
class host
{
typedef TPrintPolicy print_policy;
T data;
public:
host(T const & d) : data(d) {}
void print()
{
print_policy::print(data);
}
};
Тестовый код:
int main()
{
host<int, cout_print_policy> ic(100);
host<double, cout_print_policy> dc(100.0);
host<int, printf_print_policy> ip(100);
host<double, printf_print_policy> dp(100.0);
ic.print();
dc.print();
ip.print();
dp.print();
}
Выход:
printing using cout = 100
printing using cout = 100
printing int using printf = 100
printing double using printf = 100.000000
Онлайн демо: http://ideone.com/r4Zk4