为什么在类声明中定义时允许类模板成员函数的显式特化，而不是在单独定义时？

Question

I have seen a number of StackOverflow posts which say that specialization of a class template member function is not legal within C++, unless the enclosing class is also specialized.

However, another post seemed to indicate that it is possible to specialize the member template function, just so long as the definition of the specialized function appears inside the class declaration of the template class, as follows:

template<typename T1, typename T2>
class A
{
public:
    template<typename TX> TX foo() {return 0;};
    template<> T1 foo<T1>() {return 1;}; // provide the specialization's definition within the class declaration: works
    //template<> T1 foo<T1>(); // ... switch to this (and provide the definition below), and it's a compile error
};

// This function definition is only present when the commented-out line of code in the class declaration is used
template<typename T1, typename T2>
template<>
T1 A<T1, T2>::foo<T1>()
{
    return 1;
}

int main(void)
{
    A<int, double> a;
    const int n = a.foo<int>(); // When the definition appears inside the class declaration, n is 1 - it works
    return 0;
}

As you can see from the comments in my code sample, when the specialized function's definition is provided within the class declaration, the code builds without error, and furthermore it runs successfully, and the value of n in function main() is 1 , as expected.

However, when moving the specialized function definition outside the class declaration, but otherwise keeping it the same, as shown, the compiler emits the error that other posts have already pointed out; in my case (Visual Studio 2010), the error is an explicit specialization of a template member must be a member of an explicit specialization .

My question is this. If explicit specializations of member functions in class templates is not allowed unless the enclosing template class is also specialized, then why does it work in my sample code if the definition is provided inside the class declaration?

Answer 1

None of the two versions should compile for different reasons.

In the first case, specializations must be present at namespace level, which means that the specialization provided within the class definition should be rejected by the compiler.

In the second case, location of the specialization is correct, but to provide a specialization of a member function (specializations of functions must always be full, never partial) you need to also fix the enclosing template class arguments. That is, you cannot specialize foo for a type X regardless of which types T1 and T2 are used to instantiate the enclosing template. You are allowed (probably not what you want) to provide an specialization with all parameters fixed:

template <> template <>
int A<int, double>::foo<int>() { return 5; }

The alternatives that you can use are:

• provide a non-template overload, instead of a template specialization (in most cases it makes more sense to provide overloads than specializations, but this might not be the case here, as you cannot overload on the return type.
• move the function to a different template class and then perform partial specializations there.
• perform a variant of the first option: provide a single non-specialized template to be used by clients that forwards to an internal function for which different overloads are provided

example:

// inside class template:
private:
   template <typename T> T foo_impl( T* _ ) {...} // generic
   T1 foo_impl( T1 * _ ) {...}                    // concrete
public:
   template <typename T> T foo() {
      return foo_impl( (T*)0 );
   }

This way you turn a template only on the return type into a call to a function that is overloaded, and you can let the compiler resolve the problem for you.