Overloading vs. Specialization
在C++中有class templates 和function templates,这两种模版有很多区别,最重要的区别就是重载(overloading):
普通的C++类不能重载,当然类模版也不能重载;相反,普通函数可以重载,函数模版也能重载。这再正常不过,看下面的代码:
2 //
3
4 // A class template
5 template<class T> class X { /*...*/ }; // (a)
6
7 // A function template with two overloads
8 template<class T> void f( T ); // (b)
9 template<class T> void f( int, T, double ); // (c)
10
像上面未特化的模板通常叫做base templates。当然,base templates能够被特化,在特化这一点上
class templates 和function templates有很大的区别:一个class template 能够被partially specialized and/or
fully specialized,一个function template只能被fully specialized,但是由于function templates能够重载我们可以通过重载来实现和partially specialized 相当的功能。下面的代码说明了这些区别:
2 //
3
4 // A partial specialization of (a) for pointer types
5 template<class T> class X<T*> { /*...*/ };
6
7 // A full specialization of (a) for int
8 template<> class X<int> { /*...*/ };
9
10 // A separate base template that overloads (b) and (c)
11 // -- NOT a partial specialization of (b), because
12 // there's no such thing as a partial specialization
13 // of a function template!
14 template<class T> void f( T* ); // (d)
15
16 // A full specialization of (b) for int
17 template<> void f<int>( int ); // (e)
18
19 // A plain old function that happens to overload with
20 // (b), (c), and (d) -- but not (e), which we'll
21 // discuss in a moment
22 void f( double ); // (f)
23
根据函数重载解析规则:
2 //
3 bool b;
4 int i;
5 double d;
6
7 f( b ); // calls (b) with T = bool
8 f( i, 42, d ); // calls (c) with T = int
9 f( &i ); // calls (d) with T = int
10 f( i ); // calls (e)
11 f( d ); // calls (f)
上面说的这些其实都是很简单的情况,大多数人很容易就能明白,下面的才是容易让人弄混的:
1.考虑如下代码:
2 //
3 template<class T> // (a) a base template
4 void f( T );
5
6 template<class T> // (b) a second base template, overloads (a)
7 void f( T* ); // (function templates can't be partially
8 // specialized; they overload instead)
9
10 template<> // (c) explicit specialization of (b)
11 void f<>(int* );
12
13 // ...
14
15 int * p;
16 f( p ); // calls (c)
最后一行的结果像大多数人所期望的一样,问题是:为什么期望是这个结果?
如果你期望的原因是错误的,接下来的一定会让你好奇。也许你会说:"我为int*写了一个特化版本,f(p)当然会调用c",不幸的是,这正是错误的原因!!!
2.再考虑下面的代码:
2 //
3 template<class T> // (a) same old base template as before
4 void f( T );
5
6 template<> // (c) explicit specialization, this time of (a)
7 void f<>(int* );
8
9 template<class T> // (b) a second base template, overloads (a)
10 void f( T* );
11
12 // ...
13
14 int * p;
15 f( p ); // calls (b)! overload resolution ignores
16 // specializations and operates on the base
17 // function templates only
如果这个结果让你感到惊奇,那就对了!很多人都会感到惊奇!
理解这个的关键是:Specializations don't overload,only the base templates overload.
重载解析仅仅选择base template(或者nontemplate function,如果有的话),只有当编译器已经决定了哪个
base template将会被选择,编译器才会继续往下寻找适合的特化版本,如果找到了就使用那个特化版本。
最后,应当避免特化函数模板,也要避免重载函数模板(nontemplate function的重载当然没问题)。如果一定要这样,可以使用如下方法模拟函数模板的偏特化:
2 template <class T>
3 struct FuncImpl {
4 //users, go ahead and specialize this
5 static int apply(const T & t) {
6 return 0 ;
7 }
8 };
9
10 //partial specialazation for int
11 template <>
12 struct FuncImpl<int> {
13 static int apply(int t) {
14 return 1 ;
15 }
16 };
17
18 //partial specialazation for T*
19 template <class T>
20 struct FuncImpl<T *> {
21 static int apply(T * t) {
22 return 2 ;
23 }
24 };
25
26 //users, don't touch this!
27 template <class T>
28 int func(const T & t) {
29 return FuncImpl<T> ::apply(t);
30 }
31
32 int i = 10 , r;
33 r = func('c'); //r = 0
34 r = func(8); //r = 1
35 r = func(&i); //r = 2