Явная специализация функции члена класса шаблона

Мне нужно специализировать функцию члена-шаблона для некоторого типа (скажем double). Он отлично работает, а класс X сам по себе не является классом шаблонов, но когда я делаю его, шаблон GCC начинает давать ошибки времени компиляции.

#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();
}

вот сообщение об ошибке

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()

Как я могу исправить это и в чем проблема?

Спасибо заранее.

Ответ 1

Это не работает. Вам нужно будет сказать следующее, но оно не правильно

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

}

Явно специализированные члены нуждаются в том, чтобы их окружающие шаблоны классов также были явно специализированы. Поэтому вам нужно сказать следующее, которое будет специализироваться только на элементе X<int>.

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

}

Если вы хотите, чтобы окружающий шаблон неспециализировался, у вас есть несколько вариантов. Я предпочитаю перегрузки

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>) {

   }
};

Ответ 2

Если можно использовать std::enable_if, мы можем полагаться на SFINAE (сбой замены не является ошибкой)

который будет работать следующим образом:

#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;
}

Уродливая вещь заключается в том, что при всех этих enable_if только одна специализация должна быть доступна для компилятора, иначе возникнет ошибка устранения неоднозначности. Вот почему поведение по умолчанию "получить как Т" также необходимо включить, если.

Ответ 3

Прежде всего: у вас нет специализации get_as, объявленной в вашем шаблоне класса, которая будет определена позже в коде. Поэтому сначала вам нужно сделать это:

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

Затем определите специализацию:

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

Но я бы определил его так:

template <class C> class X
{
public:
   template <class T> void get_as()
   {
   // default implementation
   }

   template <> void get_as<double>()
   {
   // specialized implementation
   }
};

ИЗМЕНИТЬ ВЫШЕ НЕ РАБОТАЕТ!

EDIT:

Оказывается, что специализация шаблонов функций не допускается в области без пространства имен, то есть в классах, шаблонах классов и т.д.

Итак, вы можете сделать это как шаблон функции пространства имен:

template <class C> class X
{
public:
}

template <class T, class C> void get_as( X<C>& obj )
{
// default implementation
}

template <class C> void get_as<double,C>( X<C>& obj )
{
// specialized implementation
}