为什么必须在类外使用template <>对成员模板方法进行专门化

Question

I am not clear of when and how template functions are created by compiler. So I cannot explain the behavior of following 2 examples.

Example 1.

struct C1 {                                                    
    template <typename T>
    void g(T t);
};

template<>   
void C1::g(double x) {
    cout << "Member templates. C1::g(double) " << x << endl;
}

The above code builds and runs. However, without the template<> , g++ complains.

error: prototype for ‘void C1::g(double)’ does not match any in class ‘C1’

But it is OK if I place the definition of g(double ) inside the class.

Question 1: Why member template method have to be specialized using template<> outside of class?

Example 2.

struct C1 {                                                          
    template <typename T>
    void g(T t);

    void g(double x) {
        cout << "C1::g(double): " << x << endl;
    }
};

template<>
void C1::g(double x) {
    cout << "Member templates. C1::g(double) " << x << endl;
}

C1 c;
c.g(10.5); // output: C1::g(double): 10.5

The member template template void g() is not called. Which makes me wonder

Question 2. Does the member template ever gets specialized?

Answer 1

The member template template void g() is not called. Which makes me wonder

It's function overloading issue here, and the non-template function will win a template specialization in overloading resolution.

http://en.cppreference.com/w/cpp/language/overload_resolution

Best viable function

For each pair of viable function F1 and F2, the implicit conversion sequences from the i-th parameter to i-th argument are ranked to determine which one is better (except the first argument, the implicit object argument for static member functions has no effect on the ranking)

F1 is determined to be a better function than F2 if implicit conversions for all arguments of F1 are not worse than the implicit conversions for all arguments of F2, and

1) there is at least one argument of F1 whose implicit conversion is better than the corresponding implicit conversion for that argument of F2

2) or. if not that, (only in context of non-class initialization by conversion), the standard conversion sequence from the return type of F1 to the type being initialized is better than the standard conversion sequence from the return type of F2

3) or, if not that, F1 is a non-template function while F2 is a template specialization

4) or, if not that, F1 and F2 are both template specializations and F1 is more specialized according to the partial ordering rules for template specializations

You can call the template specialization function explicitly:

c.g<>(10.5); // output: Member templates. C1::g(double) 10.5

LIVE