c++ - especialización explícita de la función de miembro de clase de plantilla

templates gcc

Question

Necesito especializar la función de miembro de plantilla para algún tipo (digamos doble ). Funciona bien, mientras que la clase X sí misma no es una clase de plantilla, pero cuando lo hago, la plantilla GCC comienza a dar errores en tiempo de compilación.

#include <iostream>
#include <cmath>

template <class C> class X
{
public:
   template <class T> void get_as();
};

template <class C>
void X<C>::get_as<double>()
{

}

int main()
{
   X<int> x;
   x.get_as();
}

Aquí está el mensaje de error

source.cpp:11:27: error: template-id
  ''get_as<double>'' in declaration of primary template
source.cpp:11:6: error: prototype for
  ''void X<C>::get_as()'' does not match any in class ''X<C>''
source.cpp:7:35: error: candidate is:
  template<class C> template<class T> void X::get_as()

¿Cómo puedo solucionar eso y cuál es el problema aquí?

Gracias por adelantado.

Answer 1

No funciona de esa manera. Debería decir lo siguiente, pero no es correcto

template <class C> template<>
void X<C>::get_as<double>()
{

}

Los miembros explícitamente especializados necesitan que las plantillas de clase que los rodean también estén explícitamente especializadas. Por lo tanto, debe decir lo siguiente, que solo especializaría al miembro para X<int> .

template <> template<>
void X<int>::get_as<double>()
{

}

Si desea mantener la plantilla circundante no especializada, tiene varias opciones. Prefiero sobrecargas

template <class C> class X
{
   template<typename T> struct type { };

public:
   template <class T> void get_as() {
     get_as(type<T>());
   }

private:
   template<typename T> void get_as(type<T>) {

   }

   void get_as(type<double>) {

   }
};

Answer 2

Si uno puede usar std::enable_if podemos confiar en SFINAE (la falla de sustitución no es un error)

eso funcionaría así:

#include <iostream>
#include <type_traits>

template <class C> class X
{
public:
    template <class T, typename std::enable_if< ! std::is_same<double,T>::value>::type * = nullptr > void get_as(){
        std::cout << "get as T" << std::endl;
    }


    template <class T, typename std::enable_if< std::is_same<double,T>::value>::type * = nullptr  > void get_as(){
        std::cout << "get as double" << std::endl;
    }
};


int main()
{

    X<int> d;
    d.get_as<double>();

   return 0;
}

Lo feo es que, con todas estas enable_if, solo una especialización debe estar disponible para el compilador, de lo contrario, surgirá un error de desambiguación. Es por eso que el comportamiento predeterminado "obtener como T" también necesita habilitar.