How to Correctly Explicitly Specialize Member Functions in Templated Classes?

Explicit Specialization of Member Functions in Class Templates

When working with class templates, explicit specialization of member functions is a common requirement. However, in cases where the class template itself becomes a template, errors may arise due to an incorrect approach.

Consider the following scenario:

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

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

This code attempts to explicitly specialize a member function of class template X for the double type. However, when X itself is made a template, the compiler reports errors:

error: template-id 'get_as<double>' in declaration of primary template
error: prototype for 'void X<C>::get_as()' does not match any in class 'X<C>'

The solution is to explicitly specialize the surrounding class template as well. This can be done by adding an empty template argument to the specialized member definition:

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

This will specialize the member function only for X.

Alternatively, it's possible to use overloads to achieve the desired behavior:

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

This approach relies on template specialization to select the appropriate get_as() overload, ensuring that the double type specialization is applied as intended.

The above is the detailed content of How to Correctly Explicitly Specialize Member Functions in Templated Classes?. For more information, please follow other related articles on the PHP Chinese website!