plantilla de especialización de clase de plantilla

Question

que quieran especializarse siguiente función miembro:

class foo { 
    template<typename T> 
    T get() const; 
}; 

Para otra clase bar que depende de las plantillas también.

Por ejemplo, me gustaría ser barstd::pair con algunos parámetros de plantilla, algo así:

template<> 
std::pair<T1,T2> foo::get() const 
{ 
    T1 x=...; 
    T2 y=...; 
    return std::pair<T1,T2>(x,y); 
} 

Donde T1 y T2 son las plantillas también. ¿Cómo puede hacerse esto? Por lo que sé, debería ser posible.

Así que ahora puedo llamar:

some_foo.get<std::pair<int,double> >(); 

La respuesta final completo /:

template<typename T> struct traits; 
class foo { 
    template<typename T> 
    T get() const 
    { 
     return traits<T>::get(*this); 
    } 
}; 

template<typename T> 
struct traits { 
    static T get(foo &f) 
    { 
     return f.get<T>(); 
    } 
}; 

template<typename T1,typename T2> 
struct traits<std::pair<T1,T2> > { 
     static std::pair<T1,T2> get(foo &f) 
     { 
       T1 x=...; 
       T2 y=...; 
       return std::make_pair(x,y); 
     } 
}; 

Answer 1

No puede especializarse parcialmente plantillas de función, lo siento, pero esas son las reglas. Usted puede hacer algo como:

class foo { 
    ... 
}; 


template<typename T> 
struct getter { 
    static T get(const foo& some_foo); 
}; 

template<typename T1, typename T2> 
struct getter< std::pair<T1, T2> > { 
static std::pair<T1, T2> get(const foo& some_foo) { 
    T1 t1 = ...; 
    T2 t2 = ...; 
    return std::make_pair(t1, t2); 
}; 

y luego llamar así

getter<std::pair<int, double> >::get(some_foo); 

sin embargo. Es posible que tenga que jugar un poco con friend enviar o visibilidad si get realmente necesita ser una función miembro.

Para más detalles sobre la sugerencia de OSE:

class foo { 
    ... 
    template<typename T> 
    T get() const; 
}; 

template<typename T> 
T foo::get() const 
{ 
    return getter<T>::get(*this); 
    /*   ^-- specialization happens here */ 
} 

Y ahora que has vuelto a ser capaz de decir

std::pair<int,double> p = some_foo.get<std::pair<int, double> >(); 

Answer 2

Es necesario sobrecargar su función de miembro de par, como en

template <T, V> std::pair<T, V> foo::get() 

En el caso general, tendrá que ser capaz de desambiguar entre las diversas sobrecargas. En el caso, la desambiguación es fácil porque el par se modela en 2 tipos, mientras que el miembro original se modeló solo en T.

Si por el contrario necesitas una especialización para, por ejemplo, std :: vector, que es para un contenedor con una plantilla de parámetro único, debes tener cuidado ya que puede ser confuso para el compilador saber si deseas una instancia de la especialización de plantilla en la plantilla T es std :: vector o la especialización para la sobrecarga,

template <T> std::<vector <T> foo::get() const 

Su sintaxis propuesta no puede trabajar ya que se especializan por completo la función miembro,

template <>,

pero está omitiendo dos tipos no especificados, T1 y T2.