template<typename T>
struct S
{
typedef T resultT;
void foo(resultT&t);
};

template<typename T>
void xxx_foo(typename S<T>::resultT&t)
{
t = T();
}
void xxx_foo(S<double>::resultT&t)
{
t = -1;
}
template<typename T>
void S<T>::foo(typename S<T>::resultT&t)
{
xxx_foo<T>(t);
}



int main()
{
double dd;
S<double> s;
s.foo(dd);
S<void*> s2 ;
void* vp;
s2.foo(vp);
cout << dd << endl << vp;
return 0;
}

template<typename T> struct xxx;

template<typename U>
struct xxx<S<U>>
{    
    static void foo(U &t)
    {
        t = U();
    }
};


template<>
struct xxx<S<double>>
{
    static void foo(double &t)
    {
        t = -1;
    }
};


template<typename T>
void S<T>::foo(typename S<T>::resultT &t)
{
    xxx<S<T>>::foo(t);
}

C>template<typename T>
C>struct S
C>{
C>typedef T resultT;
C>void foo(resultT&t);
C>};

C>template<typename T>
C>void xxx_foo(typename S<T>::resultT&t)
C>{
C>t = T();
C>}
C>void xxx_foo(S<double>::resultT&t)
C>{
C>t = -1;
C>}
C>template<typename T>
C>void S<T>::foo(typename S<T>::resultT&t)
C>{
C>xxx_foo<T>(t);
C>}



C>int main()
C>{
C>double dd;
C>S<double> s;
C>s.foo(dd);
C>S<void*> s2 ;
C>void* vp;
C>s2.foo(vp);
C>cout << dd << endl << vp;
C>return 0;
C>}
C>

#include <iostream>
using namespace std;

template<typename T>
class A{
public:
    typedef T resultT;
    void m(typename A<T>::resultT &e);
};
template<typename T>
void A<T>::m(typename A<T>::resultT &e){
    e= 0;
}

template<>
class A<double>{
public:
    typedef double resultT;
    void m(A<double>::resultT &m);
};

void A<double>::m(resultT &m){
        m = -1;
}


int _tmain(int argc, _TCHAR* argv[])
{
    int t1;
    A<int> a;
    a.m(t1);
    double t2;
    A<double> b;
    b.m(t2);
    cout << t1 << " " << t2 << endl;
    system("PAUSE");
    return 0;
}

template<typename T>
struct TypeWrapper
{
    typedef typename T myType;
    myType default()
    {
        return myType();
    }
};
template<typename T>
TypeWrapper<T> typeReasoner(const typename T& value)
{
    return TypeWrapper<T>();
}


struct TypeFramework
{
    template<typename T>
    TypeFramework(const typename TypeWrapper<T>& function)
    {
        printf("random type \n");
    };
    TypeFramework(const TypeWrapper<double>& function)
    {
        printf("double type \n");
    }
};

    
int _tmain(int argc, _TCHAR* argv[])
{
    typedef double hiddenType;
    double a;
    hiddenType b;
    void* c;
    TypeFramework(typeReasoner(a));
    TypeFramework(typeReasoner(b));
    TypeFramework(typeReasoner(c));
    return 0;
}

template<class T> struct resetter
{
  template<class V> static void reset(V& v) { v = V(); }
};
template<> struct resetter<double>
{
  template<class V> static void reset(V& v) { v = -1; }
};

// или так

template<class T> struct initializer
{
  template<class V> static V init() { return V(); }
};
template<> struct initializer<double>
{
  template<class V> static void init() { return -1; }
};

....

template<class T> struct S : resetter<T>
{
  void foo()
  {
    .....
    X x = initializer<T>::init<X>(); // если не унаследовались от инструмента
    // либо
    X x;
    reset(x); // если унаследовались от инструмента
    .....
};