# woaidongmao

## 为什么不要特化函数模版

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

class templatesfunction templates有很大的区别：一个class template 能够被partially specialized and/or
fully specialized，一个function template只能被fully specialized，但是由于function templates能够重载我们可以通过重载来实现和partially specialized 相当的功能。下面的代码说明了这些区别：

1 // Example 1, continued: Specializing templates
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

1 // Example 1, continued: Overload resolution
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.考虑如下代码：

1 // Example 2: Explicit specialization
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

9
10 template<>        // (c) explicit specialization of (b)
11 void f<>(int* );
12

13 // ...
14
15 int * p;
16 f( p );           // calls (c)

2.再考虑下面的代码：

1 // Example 3
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 );           //
16                   //
specializations and operates on the base
17                   // function templates only

base template将会被选择，编译器才会继续往下寻找适合的特化版本，如果找到了就使用那个特化版本。

1 //base template class,
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

posted on 2008-10-13 11:26 肥仔 阅读(285) 评论(0)  编辑 收藏 引用 所属分类: C++ 模板