8 模板

8.1 模板起源

8.1.1 针对具体类型的实现

C和C++语言的静态类型系统，在满足效率与安全性要求的同时，很大程度上也成为阻碍程序员编写通用代码的桎梏。它迫使人们不得不为每一种数据类型编写完全或几乎完全相同的实现，虽然它们在抽象层面上是一致的。

xxxxxxxxxx
67
1
// typed.cpp
2

3
// 针对不同的类型定义不同的函数
4

5
#include <iostream>
6

7
using namespace std;
8

9
// 整型版本
10

11
int min_int(int x, int y) {
12
    return x < y ? x : y;
13
}
14

15
int max_int(int x, int y) {
16
    return x < y ? y : x;
17
}
18

19
// 双精度型版本
20

21
double min_double(double x, double y) {
22
    return x < y ? x : y;
23
}
24

25
double max_double(double x, double y) {
26
    return x < y ? y : x;
27
}
28

29
// 字符串型版本
30

31
string min_string(string x, string y) {
32
    return x < y ? x : y;
33
}
34

35
string max_string(string x, string y) {
36
    return x < y ? y : x;
37
}
38

39
// 测试用例
40

41
int main(void) {
42
    cout << "Enter two integer: " << flush;
43
    int nx, ny;
44
    cin >> nx >> ny;
45
    cout << "min=" << min_int(nx, ny) << endl;
46
    cout << "max=" << max_int(nx, ny) << endl;
47

48
    cout << "Enter two double: " << flush;
49
    double dx, dy;
50
    cin >> dx >> dy;
51
    cout << "min=" << min_double(dx, dy) << endl;
52
    cout << "max=" << max_double(dx, dy) << endl;
53

54
    cout << "Enter two string: " << flush;
55
    string sx, sy;
56
    cin >> sx >> sy;
57
    cout << "min=" << min_string(sx, sy) << endl;
58
    cout << "max=" << max_string(sx, sy) << endl;
59

60
    cout << "Enter two string: " << flush;
61
    char cx[256], cy[256];
62
    cin >> cx >> cy;
63
    cout << "min=" << min_string(cx, cy) << endl;
64
    cout << "max=" << max_string(cx, cy) << endl;
65

66
    return 0;
67
}

8.1.2 借助参数宏摆脱类型的限制

宏定义只是在预处理器的作用下，针对源代码的文本替换，其本身不具备函数语义。因此借助于参数宏（又名宏函数）可以在某种程度上使程序的编写者摆脱那些源于类型的约束和限制，但同时也丧失了类型的安全性。

xxxxxxxxxx
42
1
// untyped.cpp
2

3
// 借助参数宏摆脱了类型限制，同时也因为失去类型检查而引入风险
4

5
#include <iostream>
6

7
using namespace std;
8

9
// 宏————去类型化
10

11
#define min(x, y) ((x) < (y) ? (x) : (y))
12
#define max(x, y) ((x) < (y) ? (y) : (x))
13

14
// 测试用例
15

16
int main(void) {
17
    cout << "Enter two integer: " << flush;
18
    int nx, ny;
19
    cin >> nx >> ny;
20
    cout << "min=" << min(nx, ny) << endl;
21
    cout << "max=" << max(nx, ny) << endl;
22

23
    cout << "Enter two double: " << flush;
24
    double dx, dy;
25
    cin >> dx >> dy;
26
    cout << "min=" << min(dx, dy) << endl;
27
    cout << "max=" << max(dx, dy) << endl;
28

29
    cout << "Enter two string: " << flush;
30
    string sx, sy;
31
    cin >> sx >> sy;
32
    cout << "min=" << min(sx, sy) << endl;
33
    cout << "max=" << max(sx, sy) << endl;
34

35
    cout << "Enter two string: " << flush;
36
    char cx[256], cy[256];
37
    cin >> cx >> cy;
38
    cout << "min=" << min(cx, cy) << endl; // ?
39
    cout << "max=" << max(cx, cy) << endl; // ?
40

41
    return 0;
42
}

8.1.3 让预编译器写代码

利用宏定义构建通用代码的框架，让预处理器将其扩展为针对不同类型的具体版本。将宏的一般性和函数的类型安全性完美地结合起来。

xxxxxxxxxx
65
1
// macro.cpp
2

3
// 借助预处理器产生类似模板的功能
4

5
#include <iostream>
6

7
using namespace std;
8

9
// 模板宏
10

11
#define MIN(T) \
12
T min_##T(T x, T y) { \
13
    return x < y ? x : y; \
14
}
15

16
#define MAX(T) \
17
T max_##T(T x, T y) { \
18
    return x < y ? y : x; \
19
}
20

21
// 将模板宏扩展为具体函数
22

23
MIN(int)
24
MAX(int)
25

26
MIN(double)
27
MAX(double)
28

29
MIN(string)
30
MAX(string)
31

32
// 函数名宏
33

34
#define min(T) min_##T
35
#define max(T) max_##T
36

37
// 测试用例
38

39
int main(void) {
40
    cout << "Enter two integer: " << flush;
41
    int nx, ny;
42
    cin >> nx >> ny;
43
    cout << "min=" << min(int)(nx, ny) << endl;
44
    cout << "max=" << max(int)(nx, ny) << endl;
45

46
    cout << "Enter two double: " << flush;
47
    double dx, dy;
48
    cin >> dx >> dy;
49
    cout << "min=" << min(double)(dx, dy) << endl;
50
    cout << "max=" << max(double)(dx, dy) << endl;
51

52
    cout << "Enter two string: " << flush;
53
    string sx, sy;
54
    cin >> sx >> sy;
55
    cout << "min=" << min(string)(sx, sy) << endl;
56
    cout << "max=" << max(string)(sx, sy) << endl;
57

58
    cout << "Enter two string: " << flush;
59
    char cx[256], cy[256];
60
    cin >> cx >> cy;
61
    cout << "min=" << min(string)(cx, cy) << endl;
62
    cout << "max=" << max(string)(cx, cy) << endl;
63

64
    return 0;
65
}

8.2 函数模板

xxxxxxxxxx
49
1
// functmpl.cpp
2

3
// 函数模板
4

5
#include <iostream>
6

7
using namespace std;
8

9
// 定义函数模板
10

11
template<class T>
12
T min(T x, T y) {
13
    return x < y ? x : y;
14
}
15

16
template<typename T>
17
T max(T x, T y) {
18
    return x < y ? y : x;
19
}
20

21
// 使用函数模板
22

23
int main (void) {
24
    cout << "Enter two integer: " << flush;
25
    int nx, ny;
26
    cin >> nx >> ny;
27
    cout << "min=" << ::min<int>(nx, ny) << endl;
28
    cout << "max=" << ::max<int>(nx, ny) << endl;
29

30
    cout << "Enter two double: " << flush;
31
    double dx, dy;
32
    cin >> dx >> dy;
33
    cout << "min=" << ::min<double>(dx, dy) << endl;
34
    cout << "max=" << ::max<double>(dx, dy) << endl;
35

36
    cout << "Enter two string: " << flush;
37
    string sx, sy;
38
    cin >> sx >> sy;
39
    cout << "min=" << ::min<string>(sx, sy) << endl;
40
    cout << "max=" << ::max<string>(sx, sy) << endl;
41

42
    cout << "Enter two string: " << flush;
43
    char cx[256], cy[256];
44
    cin >> cx >> cy;
45
    cout << "min=" << ::min<string>(cx, cy) << endl;
46
    cout << "max=" << ::max<string>(cx, cy) << endl;
47

48
    return 0;
49
}

8.2.1 函数模板的定义

8.2.1.1 模板参数的语法形式

模板的类型参数必须用如下形式的语法来声明：

xxxxxxxxxx
1
1
template<typename 类型形参1, typename 类型形参2, ...>

例如：

xxxxxxxxxx
5
1
template<typename A, typename b, typename _C>
2
A function(b arg) {
3
    _C var;
4
    ...
5
}

这里的typename关键字也可以换成class，但建议使用typename。

8.2.1.2 类型参数

可以使用任何标识符作为类型参数的名称，但使用“T”已经成为了一种惯例。类型参数“T”表示的是，调用者调用这个函数时所指定的任意类型。

可以将任何具体的类型实参（基本类型、自定义类型、类类型等）传递给模板的类型形参，前提是所使用的类型实参必须能够满足该模板所需要的操作。比如将一个不支持小于操作符（<）的类型实参，传递给min或max模板的类型形参，将引发编译错误。

xxxxxxxxxx
9
1
template<class T>
2
T min(T x, T y) {
3
    return x < y ? x : y; // 传递给函数模板min的类型形参T的类型实参，必须支持小于操作符（<）
4
}
5

6
template<typename T>
7
T max(T x, T y) {
8
    return x < y ? y : x; // 传递给函数模板max的类型形参T的类型实参，必须支持小于操作符（<）
9
}

8.2.2 函数模板的使用

8.2.2.1 模板实例化

通常而言，并不是把模板编译成一个可以处理任何类型的单一实体，而是针对传递给模板类型形参的每一种类型实参，都从模板产生出一个以具体类型实现的独立实体。这种以具体类型代替类型参数的过程称为模板的实例化。每个以具体类型实现的独立实体都是该模板的一个实例。

函数模板min的三个实例：

xxxxxxxxxx
11
1
int min(int x, int y) {
2
    return x < y ? x : y;
3
}
4

5
double min(double x, double y) {
6
    return x < y ? x : y;
7
}
8

9
string min(string x, string y) {
10
    return x < y ? x : y;
11
}

函数模板max的三个实例：

xxxxxxxxxx
11
1
int max(int x, int y) {
2
    return x < y ? y : x;
3
}
4

5
double max(double x, double y) {
6
    return x < y ? y : x;
7
}
8

9
string max(string x, string y) {
10
    return x < y ? y : x;
11
}

8.2.2.2 使用函数模板时才实例化

函数模板的类型实参放在尖括号中，调用实参放在圆括号中，类型实参必须位于函数模板名和调用实参之间：

xxxxxxxxxx
1
1
函数模板名<类型实参1, 类型实参2, ...>(调用实参1, 调用实参2, ...);

只要使用函数模板，编译器就会自动引发这样一个实例化过程，程序员并不需要额外地请求对模板实例化。例如：

• min<int>(nx, ny)实例化出int min(int x, int y) { ... }函数，并调用之

• max<int>(nx, ny)实例化出int max(int x, int y) { ... }函数，并调用之

• min<double>(dx, dy)实例化出double min(double x, double y) { ... }函数并调用之

• max<double>(dx, dy)实例化出double max(double x, double y) { ... }函数并调用之

• min<string>(sx, sy)实例化出string min(string x, string y) { ... }函数并调用之

• max<string>(sx, sy)实例化出string max(string x, string y) { ... }函数并调用之

• min<string>(cx, cy)直接调用已经实例化的string min(string x, string y) { ... }函数

• max<string>(cx, cy)直接调用已经实例化的string max(string x, string y) { ... }函数

8.2.2.3 二次编译

每个函数模板事实上都被编译了两次：

• 一次是在实例化之前，先检查模板代码本身，查看语法是否正确

• 另一次是在实例化期间，结合传入的类型实参，再次检查模板代码，查看针对具体类型的所有操作是否都有效

只有在第二次编译时，才会真正产生针对具体函数的二进制机器指令，第一次编译仅仅在编译器内部形成的一个用于描述函数模板的内部表示。

8.2.3 函数模板的隐式推断

8.2.3.1 根据调用参数推断模板参数

如果函数模板调用参数的类型相关于该模板的类型参数，那么在调用该函数模板时，即使不显式指明类型实参，编译器也有能力根据调用参数的类型隐式推断出正确的类型实参，以获得与普通函数调用一致的语法表达。例如：

xxxxxxxxxx
27
1
int main (void) {
2
    cout << "Enter two integer: " << flush;
3
    int nx, ny;
4
    cin >> nx >> ny;
5
    cout << "min=" << ::min(nx, ny) << endl;
6
    cout << "max=" << ::max(nx, ny) << endl;
7

8
    cout << "Enter two double: " << flush;
9
    double dx, dy;
10
    cin >> dx >> dy;
11
    cout << "min=" << ::min(dx, dy) << endl;
12
    cout << "max=" << ::max(dx, dy) << endl;
13

14
    cout << "Enter two string: " << flush;
15
    string sx, sy;
16
    cin >> sx >> sy;
17
    cout << "min=" << ::min(sx, sy) << endl;
18
    cout << "max=" << ::max(sx, sy) << endl;
19

20
    cout << "Enter two string: " << flush;
21
    char cx[256], cy[256];
22
    cin >> cx >> cy;
23
    cout << "min=" << ::min<string>(cx, cy) << endl;
24
    cout << "max=" << ::max<string>(cx, cy) << endl;
25

26
    return 0;
27
}

注意在cx和cy中获取最小和最大值的函数模板调用没有使用隐式推断：

xxxxxxxxxx
2
1
cout << "min=" << ::min(cx, cy) << endl;
2
cout << "max=" << ::max(cx, cy) << endl;

而依然使用显式实例化：

xxxxxxxxxx
2
1
cout << "min=" << ::min<string>(cx, cy) << endl;
2
cout << "max=" << ::max<string>(cx, cy) << endl;

因为cx和cy是字符数组，其类型为char*，隐式推断将以char*作为实例化函数模板的类型实参，实例化结果为：

xxxxxxxxxx
7
1
char* min(char* x, char* y) {
2
    return x < y ? x : y;
3
}
4

5
char* max(char* x, char* y) {
6
    return x < y ? y : x;
7
}

对由字符指针指向的空字符结尾的C风格字符串，使用小于号比较大小，显然是不合适的。

8.2.3.2 不能隐式推断的三种情况

以下三种情况，不能隐式推断，必须显式指定模板参数：

• 不是全部模板参数都与调用参数的类型相关

  xxxxxxxxxx
  1
  1
  template<typename V, typename A> void foo(A arg) { ... V var ... }
  

  xxxxxxxxxx
  3
  1
  foo(1.23); // 错误
  2
  foo<int, double>(1.23); // 正确
  3
  foo<int>(1.23); // 正确
  

• 隐式推断的同时不允许隐式类型转换

  xxxxxxxxxx
  1
  1
  template<typename T> void foo(T x, T y) { ... }
  

  xxxxxxxxxx
  3
  1
  foo(123, 4.56); // 错误
  2
  foo<double>(123, 4.56); // 正确
  3
  foo(123, (int)4.56); // 正确
  

• 返回类型不能隐式推断

  xxxxxxxxxx
  1
  1
  template<typename R, typename A> R foo(A arg) { ... }
  

  xxxxxxxxxx
  3
  1
  int ret = foo(1.23); // 错误
  2
  int ret = foo<int, double>(1.23); // 正确
  3
  int ret = foo<int>(1.23); // 正确
  

xxxxxxxxxx
56
1
// deduction.cpp
2

3
// 函数模板参数的隐式推断
4

5
#include <iostream>
6
#include <typeinfo>
7

8
using namespace std;
9

10
template<typename T>
11
void foo(T const& x, T const& y) {
12
    cout << typeid(T).name() << endl;
13
}
14

15
template<typename R, typename A>
16
R bar(A const& arg) {
17
    R ret;
18
    cout << typeid(R).name() << ' ' << typeid(A).name() << endl;
19
    return ret;
20
}
21

22
int main(void) {
23
    // 隐式实例化函数模板
24

25
    int a, b;
26
    foo(a, b);
27

28
    double c, d;
29
    foo(c, d);
30

31
    char e[256], f[256];
32
    foo(e, f);
33
    foo("hello", "world");
34
    // foo("hello", "tarena"); // char[6] != char[7]
35

36
    string g, h;
37
    foo(g, h);
38

39
    // 隐式推断不允许隐式类型转换
40
    // foo(a, c);
41
    // 但可以显式类型转换
42
    foo(a, (int)c);
43
    foo(static_cast<double>(a), c);
44
    // 显式实例化函数模板
45
    foo<int>(a, c);
46
    foo<double>(a, c);
47

48
    int i;
49
    double j;
50
    // 返回类型不能隐式推断
51
    // i = bar(j);
52
    i = bar<int, double>(j);
53
    i = bar<int>(j);
54

55
    return 0;
56
}

8.2.3.3 隐式推断与缺省值之间的矛盾

函数模板参数的隐式推断与缺省值之间存在矛盾，因此函数模板的模板参数不能带有缺省值。例如：

xxxxxxxxxx
1
1
template<typename T = int> T min(T x, T y) { return x < y ? x : y; } // 错误

xxxxxxxxxx
1
1
cout << ::min(1.23, 4.56) << endl; // T=double? T=int?

C++11以后，允许为函数模板的模板参数指定缺省值，但依然会优先选择隐式推断的结果。

xxxxxxxxxx
18
1
// defargs.cpp
2

3
// C++11以后，允许为函数模板的模板参数指定缺省值，但依然会优先选择隐式推断的结果
4

5
#include <iostream>
6

7
using namespace std;
8

9
template<typename T = int>
10
T min(T x, T y) {
11
    return x < y ? x : y;
12
}
13

14
int main(void) {
15
    cout << ::min(1.23, 4.56) << endl; // T=double, 1.23
16

17
    return 0;
18
}

8.2.4 函数模板的重载

xxxxxxxxxx
66
1
// overload.cpp
2

3
// 函数模板重载
4

5
#include <string.h>
6

7
#include <iostream>
8
#include <typeinfo>
9

10
using namespace std;
11

12
// 求两个C风格字符串的最小值
13
char const* min(char const* x, char const* y) {
14
    cout << "<1" << typeid(char const*).name() << "> " << flush;
15
    return strcmp(x, y) < 0 ? x : y;
16
}
17

18
// 求两个任意类型值的最小值
19
template<typename T>
20
T min(T x, T y) {
21
    cout << "<2" << typeid(T).name() << "> " << flush;
22
    return x < y ? x : y;
23
}
24

25
// 求两个任意类型指针所指向目标的最小值
26
template<typename T>
27
T* min(T* x, T* y) {
28
    cout << "<3" << typeid(T).name() << "> " << flush;
29
    return *x < *y ? x : y;
30
}
31

32
// 求三个任意类型值的最小值
33
template<typename T>
34
T min(T x, T y, T z) {
35
    cout << "<4" << typeid(T).name() << "> " << flush;
36
    return ::min(::min(x, y), z);
37
}
38

39
// 求两个C风格字符串的最小值
40
// char const* min(char const* x, char const* y) {
41
//     cout << "<1" << typeid(char const*).name() << "> " << flush;
42
//     return strcmp(x, y) < 0 ? x : y;
43
// }
44

45
int main(void) {
46
    // 编译器优先选择普通函数
47
    cout << ::min("hello", "world") << endl; // <1PKc> hello
48
    // 除非函数模板能够产生具有更好匹配性的函数实例
49
    cout << ::min(123, 456) << endl; // <2i> 123
50

51
    // 在参数传递过程中如需隐式类型转换，编译器将优先选择普通函数
52
    char s[] = "hello";
53
    cout << ::min(s, "world") << endl; // <1PKc> hello
54

55
    // 通过空模板参数列表告知编译器使用函数模板
56
    // 针对指针的版本显然比任意类型版本更加匹配
57
    cout << ::min<>("hello", "hellooo") << endl; // <3c> hellooo
58

59
    // 显式指定的模板参数必须在所选择的重载版本中与调用参数的类型保持一致
60
    cout << ::min<char const*>("hello", "world") << endl; // <2PKc> world
61

62
    // 在函数模板的实例化函数中，编译器仍然优先选择普通函数
63
    cout << ::min("hello", "world", "tarena") << endl; // <4PKc> <1PKc> <1PKc> hello
64

65
    return 0;
66
}

8.2.4.1 普通函数和函数模板构成重载

普通函数和可实例化为该函数的函数模板构成重载关系。在其它条件都相同的情况下，编译器优先选择普通函数，除非函数模板能够产生具有更好匹配性的函数实例。

xxxxxxxxxx
2
1
char const* min(char const* x, char const* y) { ... } // 普通函数
2
template<typename T> T min(T x, T y) { ... } // 函数模板

xxxxxxxxxx
2
1
cout << ::min("hello", "world") << endl; // 调用普通函数
2
cout << ::min(123, 456) << endl; // 调用函数模板实例

8.2.4.2 函数模板不支持隐式类型转换

函数模板的隐式实例化不支持隐式类型转换，但普通函数支持。因此在参数传递过程中如需隐式类型转换，编译器将优先选择普通函数。

xxxxxxxxxx
2
1
char const* min(char const* x, char const* y) { ... } // 普通函数
2
template<typename T> T min(T x, T y) { ... } // 函数模板

xxxxxxxxxx
2
1
char s[] = "hello";
2
cout << ::min(s, "world") << endl; // 调用普通函数，char*->char const*

8.2.4.3 显式指定空模板参数列表

可以显式指定一个空的模板参数列表，明确告知编译器使用函数模板，但模板参数却由隐式推断决定。即便是在函数模板中选择，编译器也会尽可能选择类型约束性强的版本，即更特殊的版本。

xxxxxxxxxx
3
1
char const* min(char const* x, char const* y) { ... } // 普通函数
2
template<typename T> T min(T x, T y) { ... } // 函数模板
3
template<typename T> T* min(T* x, T* y) { ... } // 更特殊的函数模板

xxxxxxxxxx
1
1
cout << ::min<>("hello", "hellooo") << endl; // 调用更特殊的函数模板实例

8.2.4.4 保证模板参数与调用参数一致

如果为函数模板显式指定了模板参数，那么所选择的重载版本必须能够保证模板参数与调用参数的类型一致。

xxxxxxxxxx
3
1
char const* min(char const* x, char const* y) { ... } // 普通函数
2
template<typename T> T min(T x, T y) { ... } // 函数模板
3
template<typename T> T* min(T* x, T* y) { ... } // 更特殊的函数模板

xxxxxxxxxx
1
1
cout << ::min<char const*>("hello", "world") << endl; // 调用函数模板实例

8.2.4.5 函数模板内优先选择普通函数

即使是在函数模板的实例化函数中，编译器仍然优先选择普通函数，前提是该普通函数在一次编译时可见。

xxxxxxxxxx
5
1
char const* min(char const* x, char const* y) { ... } // 普通函数
2
template<typename T> T min(T x, T y) { ... } // 两参函数模板
3
template<typename T> T min(T x, T y, T z) {
4
    return ::min(::min(x, y), z);
5
} // 三参函数模板

xxxxxxxxxx
1
1
cout << ::min("hello", "world", "tarena") << endl; // 调用三参函数模板实例，后者调用普通函数

8.2.4.6 重载函数模板最好只针对参数的个数或具体类型

xxxxxxxxxx
40
1
// bad.cpp
2

3
// 重载函数模板最好只针对参数的个数或具体类型，否则极可能导致非预期的后果
4

5
#include <string.h>
6

7
#include <iostream>
8
#include <typeinfo>
9

10
using namespace std;
11

12
template<typename T>
13
T const& min(T const& x, T const& y) {
14
    return x < y ? x : y;
15
}
16

17
// 正确的写法
18
char const* const& min(char const* const& x, char const* const& y) {
19
    return strcmp(x, y) < 0 ? x : y;
20
}
21

22
/* 错误的写法
23
char const* min(char const* x, char const* y) {
24
    return strcmp(x, y) < 0 ? x : y;
25
}
26
*/
27
template<typename T>
28
T const& min(T const& x, T const& y, T const& z) {
29
    return ::min(::min(x, y), z); // 返回对匿名局部变量的引用
30
}
31

32
int main(void) {
33
    char const* a = "a";
34
    char const* b = "ab";
35
    char const* c = "abc";
36
    char const* const& d = ::min(a, b, c);
37
    cout << d << endl;
38

39
    return 0;
40
}

8.3 类模板

xxxxxxxxxx
60
1
// clstmpl.cpp
2

3
// 类模板
4

5
#include <iostream>
6

7
using namespace std;
8

9
// 定义类模板
10

11
template<class T>
12
class Comparator {
13
public:
14
    Comparator(T x, T y) : x(x), y(y) {}
15

16
    T min(void) const {
17
        return x < y ? x : y;
18
    }
19

20
    T max(void) const {
21
        return x < y ? y : x;
22
    }
23

24
private:
25
    T x, y;
26
};
27

28
// 使用类模板
29

30
int main (void) {
31
    cout << "Enter two integer: " << flush;
32
    int nx, ny;
33
    cin >> nx >> ny;
34
    Comparator<int> cn(nx, ny);
35
    cout << "min=" << cn.min() << endl;
36
    cout << "max=" << cn.max() << endl;
37

38
    cout << "Enter two double: " << flush;
39
    double dx, dy;
40
    cin >> dx >> dy;
41
    Comparator<double> cd(dx, dy);
42
    cout << "min=" << cd.min() << endl;
43
    cout << "max=" << cd.max() << endl;
44

45
    cout << "Enter two string: " << flush;
46
    string sx, sy;
47
    cin >> sx >> sy;
48
    Comparator<string> cs(sx, sy);
49
    cout << "min=" << cs.min() << endl;
50
    cout << "max=" << cs.max() << endl;
51

52
    cout << "Enter two string: " << flush;
53
    char cx[256], cy[256];
54
    cin >> cx >> cy;
55
    cs = Comparator<string>(cx, cy);
56
    cout << "min=" << cs.min() << endl;
57
    cout << "max=" << cs.max() << endl;
58

59
    return 0;
60
}

8.3.1 类模板的定义

8.3.1.1 模板参数的语法形式

模板的类型参数必须用如下形式的语法来声明：

xxxxxxxxxx
1
1
template<typename 类型形参1, typename 类型形参2, ...>

例如：

xxxxxxxxxx
6
1
template<typename A, typename b, typename _C>
2
class MyClass {
3
public:
4
    A a;
5
    b foo(_C c) { ... };
6
};

这里的typename关键字也可以换成class，但建议使用typename。

8.3.1.2 类型参数

在类模板的内部，类型参数可以象其它任何具体类型一样，用于成员变量、成员函数、成员类型（内部类型），甚至基类的声明。例如：

xxxxxxxxxx
6
1
template<typename M, typename R, typename A, typename V, typename T, typename B>
2
class MyClass : public B {
3
    M mem;
4
    R function(A arg) { ... V var ... }
5
    typedef T* pointer;
6
};

8.3.2 类模板的使用

8.3.2.1 类模板的两步实例化

从类模板到对象实际上经历了两个实例化过程

• 编译期：编译器将类模板实例化为类并生成对象创建指令

• 运行期：处理器执行对象创建指令将类实例化为内存对象

类模板本身并不代表一个确定的类型，既不能用于定义对象，也不能用于声明指针或引用。只有通过模板实参将其实例化为具体类以后，才具备类型语义。

xxxxxxxxxx
1
1
类模板名<类型实参1, 类型实参2, ...>

8.3.2.2 调用谁实例化谁

类模板中，只有那些实际被调用的成员函数才会被实例化，即产生二进制代码。某些类型虽然并没有提供类模板所需要的全部功能，但照样可以实例化该类模板，只要不直接或间接调用那些依赖于未提供功能的成员函数即可。

xxxxxxxxxx
16
1
template<class T>
2
class Comparator {
3
public:
4
    Comparator(T x, T y) : x(x), y(y) {}
5

6
    T min(void) const {
7
        return x < y ? x : y; // 若调用此函数，实例化该模板的类型，必须支持小于操作符（<）
8
    }
9

10
    T max(void) const {
11
        return x > y ? x : y; // 若调用此函数，实例化该模板的类型，必须支持大于操作符（>）
12
    }
13

14
private:
15
    T x, y;
16
};

xxxxxxxxxx
14
1
class Integer {
2
public:
3
    Integer(int n) : n(n) {}
4

5
    // 只实现了小于操作符（<）
6
    bool operator<(Integer const& i) const {
7
        return n < i.n;
8
    }
9

10
    // 没有实现大于操作符（>）
11

12
private:
13
    int n;
14
};

xxxxxxxxxx
2
1
Comparator<Integer> cn(123, 456); // 可以用Integer类实例化Comparator类模板
2
cout << cn.min() << endl; // 只要不调用max函数就没问题

8.3.2.3 类模板参数不支持隐式推断

与函数模板不同，类模板的类型参数不支持隐式推断。

xxxxxxxxxx
6
1
template<class T>
2
class Comparator {
3
public:
4
    Comparator(T x, T y) : x(x), y(y) {}
5
    ...
6
};

xxxxxxxxxx
4
1
int nx, ny;
2
...
3
Comparator<int> cn(nx, ny); // 正确
4
Comparator cn(nx, ny); // 错误

8.3.3 静态成员与递归实例化

8.3.3.1 类模板的静态成员

类模板的静态成员变量，既不是一个对象一份，也不是一个模板一份，而是在该类模板的每个实例化类中，各有一份独立的拷贝，且为该类的所有实例化对象所共享。

xxxxxxxxxx
38
1
// static.cpp
2

3
// 类模板的静态成员
4

5
#include <iostream>
6

7
using namespace std;
8

9
template<typename T>
10
class A {
11
public:
12
    static void foo(void) {
13
        cout << &n << ' ' << &t << endl;
14
    }
15

16
private:
17
    static int n;
18
    static T t;
19
};
20

21
template<typename T> int A<T>::n;
22
template<typename T> T A<T>::t;
23

24
int main(void) {
25
    A<int> a, b;
26
    a.foo();
27
    b.foo();
28

29
    A<double> c, d;
30
    c.foo();
31
    d.foo();
32

33
    A<string> e, f;
34
    e.foo();
35
    f.foo();
36

37
    return 0;
38
}

8.3.3.2 类模板的递归实例化

类模板的类型实参可以是任何类型，只要该类型能够提供模板所需要的功能即可。

类模板自身的实例化类亦可实例化其自身，谓之递归实例化。通过这种方法可以很容易地构建那些在空间上具有递归特征的数据结构。

xxxxxxxxxx
52
1
// recursion.cpp
2

3
// 类模板的递归实例化
4

5
#include <iostream>
6

7
using namespace std;
8

9
template<typename T>
10
class Array {
11
public:
12
    T& operator[](size_t i) {
13
        return arr[i];
14
    }
15

16
    T const& operator[](size_t i) const {
17
        return const_cast<Array&>(*this)[i];
18
    }
19

20
private:
21
    T arr[3];
22
};
23

24
template<typename T>
25
ostream& operator<<(ostream& os, Array<T> const& array) {
26
    for (size_t i = 0; i < 3; ++i)
27
        os << '(' << array[i] << ')';
28

29
    return os;
30
}
31

32
int main(void) {
33
    Array<int> ai;
34
    ai[0] = 100;
35
    ai[1] = 200;
36
    ai[2] = 300;
37
    cout << ai << endl;
38

39
    Array<string> as;
40
    as[0] = "北京";
41
    as[1] = "上海";
42
    as[2] = "广州";
43
    cout << as << endl;
44

45
    Array<Array<int>> aai;
46
    for (size_t i = 0; i < 3; ++i)
47
        for (size_t j = 0; j < 3; ++j)
48
            aai[i][j] = (i+1)*10+j+1;
49
    cout << aai << endl;
50

51
    return 0;
52
}

• Array<int>：一维数组

• Array<Array<int>>：二维数组

• Array<Array<Array<int>>>：三维数组

8.3.4 类模板的特化

通过特化类模板，可以优化针对某种特定类型的实现，或者克服某种特定类型在实例化类模板时所表现出的不足。

xxxxxxxxxx
60
1
// error.cpp
2

3
// 特定类型在实例化类模板时所表现出的不足
4

5
#include <iostream>
6

7
using namespace std;
8

9
// 定义类模板
10

11
template<class T>
12
class Comparator {
13
public:
14
    Comparator(T x, T y) : x(x), y(y) {}
15

16
    T min(void) const {
17
        return x < y ? x : y;
18
    }
19

20
    T max(void) const {
21
        return x < y ? y : x;
22
    }
23

24
private:
25
    T x, y;
26
};
27

28
// 使用类模板
29

30
int main (void) {
31
    cout << "Enter two integer: " << flush;
32
    int nx, ny;
33
    cin >> nx >> ny;
34
    Comparator<int> cn(nx, ny);
35
    cout << "min=" << cn.min() << endl;
36
    cout << "max=" << cn.max() << endl;
37

38
    cout << "Enter two double: " << flush;
39
    double dx, dy;
40
    cin >> dx >> dy;
41
    Comparator<double> cd(dx, dy);
42
    cout << "min=" << cd.min() << endl;
43
    cout << "max=" << cd.max() << endl;
44

45
    cout << "Enter two string: " << flush;
46
    string sx, sy;
47
    cin >> sx >> sy;
48
    Comparator<string> cs(sx, sy);
49
    cout << "min=" << cs.min() << endl;
50
    cout << "max=" << cs.max() << endl;
51

52
    cout << "Enter two string: " << flush;
53
    char cx[256], cy[256];
54
    cin >> cx >> cy;
55
    Comparator<char const*> cc(cx, cy);
56
    cout << "min=" << cc.min() << endl;
57
    cout << "max=" << cc.max() << endl;
58

59
    return 0;
60
}