在C++中有class templates 和function templates，這兩種模版有很多區別，最重要的區別就是重載(overloading)：
普通的C++類不能重載，當然類模版也不能重載；相反，普通函數可以重載，函數模版也能重載。這再正常不過，看下面的代碼：
1 // Example 1: Class vs. function template, and overloading
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 相當的功能。下面的代碼說明了這些區別：
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
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.再考慮下面的代碼：
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 ); // 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的重載當然沒問題)。如果一定要這樣，可以使用如下方法模擬函數模板的偏特化：
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