模板模板参数的专业化

Question

这是对earlier question的续集问题（不同主题）。下面的代码结合Dehstil的建议使用专业化。

具有模板模板参数的函数应该如何专用？

下面的代码（其中两个专业化行不编译）使问题具体化。

#include <cassert> 

template<typename S> struct PA1 {}; 
template<typename S> struct PA2 {}; 
template<typename S> struct PB {}; 
template<typename S> struct PC {}; 

template<typename S> struct A1 { typedef PA1<S> P; }; 
template<typename S> struct A2 { typedef PA2<S> P; }; 
template<typename S> struct B { typedef PB <S> P; }; 
template<typename S> struct C { typedef PC <S> P; }; 

template<typename S, template<typename> class T> char fn(typename T<S>::P); 

template<typename S, template<typename> class T> char fn(typename T<S>::P) 
{ 
    return 'a'; 
} 

template<typename S> char fn<B<S> >(B<S>::P) { return 'b'; } 
template<typename S> char fn<C<S> >(C<S>::P) { return 'c'; } 

int main() 
{ 
    PA1<int> pa1; 
    PA2<int> pa2; 
    PB<int> pb; 
    PC<int> pc; 
    assert((fn<int, A1>(pa1)) == 'a'); 
    assert((fn<int, A2>(pa2)) == 'a'); 

    assert((fn<int, B>(pb)) == 'b'); 
    assert((fn<int, C>(pc)) == 'c'); 
} 

这四个功能重要的电话FN < ...，...>（）调用时具有相同的特征，因为他们自己会驻留在适用于四类A1/A2模板类/公元前。

Answer 1

函数模板的部分专用化不被C++标准允许！

重载您的功能，而不是专门化它们。由Herb萨特Template Specialization and Overloading

---

如何统一调用所有功能，如果你重载

：

由Herb萨特阅读解释，Why Not Specialize Function Templates?

然后阅读为什么超载比专业

撰写班级模板call并将其专门为：

template<class S, template<typename> class T> 
struct call 
{ 
    static char fn(typename T<S>::P &p) 
    { 
     return ::fn<S,T>(p); 
    } 
}; 

template<class S> 
struct call<S,B> 
{ 
    static char fn(typename B<S>::P &p) 
    { 
     return ::fn<S>(p); 
    } 
}; 

template<class S> 
struct call<S,C> 
{ 
    static char fn(typename C<S>::P &p) 
    { 
     return ::fn<S>(p); 
    } 
}; 

然后你就可以使用这个类模板调用所有功能统一为：

assert((call<int, A1>::fn(pa1)) == 'a'); 
assert((call<int, A2>::fn(pa2)) == 'a'); 

assert((call<int, B>::fn(pb)) == 'b'); 
assert((call<int, C>::fn(pc)) == 'c'); 

见在线演示：http://www.ideone.com/TISIT

注意在完整的解决方案，在同样的重载函数模板ideone.com（以上链接）

Answer 2

函数只能完全专用。使用函数重载：

template<typename S> char fn(typename B<S>::P) { return 'b'; } 
template<typename S> char fn(typename C<S>::P) { return 'c'; }