C++模板

一、模板的起源

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

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

#include <iostream>
using namespace std;
#define max(x, y) ((x) < (y) ? (y) : (x))
int main (void) {
int a = 123, b = 456;
cout << max (a, b) << endl; // 456
double c = 1.23, d = 4.56;
cout << max (c, d) << endl; // 4.56
string e = "hello", f = "world";
cout << max (e, f) << endl; // world
char g[] = "hello", h[] = "world";
cout << max (g, h) << endl;
return 0;
}

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

#include <iostream>
using namespace std;
#define MAX(T) \
T max_##T (T x, T y) { \
return x < y ? y : x; \
}
MAX (int) // int max_int (int x, int y) { ... }
MAX (double)
MAX (string)
#define max(T) max_##T
int main (void) {
int a = 123, b = 456;
cout << max(int) (a, b) << endl;
//  cout << max_int (a, b) << endl;
double c = 1.23, d = 4.56;
cout << max(double) (c, d) << endl;
string e = "hello", f = "world";
cout << max(string) (e, f) << endl;
char g[] = "hello", h[] = "world";
cout << max(string) (g, h) << endl;
return 0;
}

二、函数模板

1.函数模板的定义

template<typename A, typename b, typename _C>
A function (b arg) {
_C bar;
...
}

2.函数模板的使用

int x = function<int, double, string> (3.14);

3.模板实例化

通常而言，并是不把模板编译成一个可以处理任何类型的单一实体，而是对于实例化模板参数的每种类型，都从模板产生出一个不同的实体。这种用具体类型代替模板参数的过程叫做实例化。它所产生的具体函数就是该模板的一个实例。

4.二次编译

与普通函数不同，模板函数要被编译两次：

第一次编译：与类型参数无关的语法检查、生成该模板的内部表示；

第二次编译：用实例化语句中的类型实参与该模板的内部表示结合，做与类型参数相关的语法检查、生成针对具体函数的二进制指令代码。

5.隐式推断

如果函数模板调用参数的类型与该模板的类型参数相关，那么在调用该函数模板时，即使不显式指定模板参数，编译器也有能力根据调用参数的类型隐式推断出模板参数的具体类型，以获得与普通函数调用一致的语法形式。

#include <cstdlib>
#include <iostream>
#include <typeinfo>
using namespace std;
template<typename T>
void foo (T const& x, T const& y) {
cout << typeid (x).name () << ' '
<< typeid (y).name () << endl;
}
template<typename T>
void bar (T x, T y) {
cout << typeid (x).name () << ' '
<< typeid (y).name () << endl;
}
template<typename R, typename T>
//template<typename T, typename R> // 错误
R hum (T const& x) {
R y;
cout << typeid (x).name () << ' '
<< typeid (y).name () << endl;
return y;
}
int main (void) {
int a, b;
foo (a, b); // i i
double c, d;
foo (c, d); // d d
char e[256], f[256];
foo (e, f); // A256_c A256_c
bar (e, f); // Pc Pc
foo ("hello", "world"); // A6_c A6_c
bar ("hello", "world"); // PKc PKc
//  foo ("hello", "tarena");// 错误
bar ("hello", "tarena");// PKc PKc
foo (string ("hello"), string ("tarena"));
// Ss Ss
//  foo (a, c); // 错误，隐式推断不能同时隐式转换
// i i X
// d d X
// i d X
// d i X
foo ((double)a, c); // d d
foo (a, (int)c); // i i
foo<double> (a, c); // d d
foo<int> (a, c); // i i
int g;
double h;
//  g = hum (h); // 错误，返回类型不参与隐式推断
g = hum<int, double> (h); // d i
g = hum<int> (h); // d i
return 0;
}

tips:要注意编译器所推断出的类型不一定和程序编写者所期望的类型一致。

6.重载

函数模板和函数模板，以及函数模板和普通函数，都可以构成重载关系。

#include <cstdlib>
#include <cstring>
#include <iostream>
#include <typeinfo>
using namespace std;
// 两个任意类型对象的最大值
template<typename T>
T const& max (T const& x, T const& y) {
cout << "<1" << typeid (x).name () << '>'
<< flush;
return x < y ? y : x;
}
// 两个任意类型指针所指向目标的最大值
template<typename T>
T* const& max (T* const& x, T* const& y) {
cout << "<2" << typeid (x).name () << '>'
<< flush;
return *x < *y ? y : x;
}
// 两个C风格字符串的最大值
// 在重载函数模板的时候，应该尽可能将改变限制在参数
// 的个数或具体类型上，否则极可能导致非预期的后果
char const* const& max (char const* const& x,
char const* const& y) {
cout << "<3" << typeid (x).name () << '>'
<< flush;
return strcmp (x, y) < 0 ? y : x;
}
/*
char const* max (char const* x, char const* y) {
return strcmp (x, y) < 0 ? y : x;
}*/
// 三个任意类型对象的最大值
template<typename T>
T const& max (T const& x, T const& y, T const& z) {
cout << "<4" << typeid (x).name () << '>'
<< flush;
// 重载解析是在函数模板第二次编译阶段进行的，因
// 此即使是在函数模板内部，同样优先选择普通函数
// 重载解析的候选范围在第一次编译的时候确定，因
// 此必须保证所有可供选择的重载版本在函数模板被
// 第一次编译时可见
return ::max (::max (x, y), z);
}
/*
char const* const& max (char const* const& x,
char const* const& y) {
cout << "<3" << typeid (x).name () << '>'
<< flush;
return strcmp (x, y) < 0 ? y : x;
}*/
int main (void) {
char const* x = "abc"; // 大
char const* y = "ab";  // 中
char const* z = "a";   // 小
// 编译器优先选择普通函数
cout << ::max (x, y) << endl; // 3
// 除非函数模板能够产生具有更好匹配性的函数
cout << ::max (123, 456) << endl; // 1
// 通过模板参数表的左右尖括号显式表明需要调用函
// 数模板，针对指针的版本比任意类型的版本更具体
cout << ::max<> (y, x) << endl; // 2
// 显式指定的模板参数必须在所选择的重载版本中与
// 调用参数的类型保持一致
cout << ::max<char const*> (y, z) << endl; // 1
const char* const& res = ::max (x, y, z);
cout << res << endl; // 4
char const* a = "123";
char const* b = "12";
char const* c = "1";
::max (a, b, c);
cout << res << endl;
return 0;
}

三、类模板

1.类模板的定义

template<typename A, typename b, typename _C>
class MyClass : b {
public:
A m_a;
void foo (_C c) { ... }
};

2.类模板的使用

MyClass<int, Human, string> obj;

3.两步实例化

编译期           运行期
类模板 -实例化-> 类 -实例化-> 对象

tips

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

2)类模板必须显式实例化，不支持隐式推断。

3)类模板本身不代表一个类型，不能用于声明对象、引用或者指针，只有通过类型参数将其实例化为具体类以后，才可以作为类型用于对象、引用或者指针的声明。

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

4.模板的特例化

一个类模板的通用版本可能对某些特殊类型并不适用，或者不够优化，这时候可以定义该类模板或其中某些成员函数针对此类型的特殊实现，谓之特例化。

1)全类特化：将整个类模板重写成针对某种具体类型的具体类。

template<>

class 类模板名<所针对的具体类型> { 具体类的实现 };

2)成员特化：将类模板中的某些与具体类型相关的成员函数，单独进行特化。

template<>

返回类型 类模板名<所针对的具体类型>::成员函数名 (形参表) { 具体实现 }

#include <cstring>
#include <iostream>
using namespace std;
template<typename T>
T max (T x, T y) {
return x < y ? y : x;
}
char const* max (char const* x, char const* y) {
return strcmp (x, y) < 0 ? y : x;
}
// 通用版本
template<typename T>
class Comparator {
public:
Comparator (T x, T y) : m_x (x), m_y (y) {}
T max (void) const {
return m_x < m_y ? m_y : m_x;
}
/*
char const* max (void) const {
return strcmp (m_x, m_y) < 0 ? m_y : m_x;
}*/
private:
T m_x, m_y;
};
/*
// 针对char const*类型的全类特化版本
template<>
class Comparator<char const*> {
public:
Comparator (char const* x, char const* y) :
m_x (x), m_y (y) {}
char const* max (void) const {
return strcmp (m_x, m_y) < 0 ? m_y : m_x;
}
private:
char const* m_x, *m_y;
};
*/
// 针对char const*类型的成员特化版本
template<>
char const* Comparator<char const*>::max (
void) const {
return strcmp (m_x, m_y) < 0 ? m_y : m_x;
}
template<typename T>
class A {
public:
static void foo (void) {
cout << "A<T>" << endl;
}
static T hum (T t) {
return t;
}
};
template<>//A的全类特化
class A<int> {
public:
static void bar (int x, int y) {
cout << "A<int> " << x << ' ' << y
<< endl;
}
};
template<> //对类A的成员特化
void A<string>::foo (/*int*/void) {
cout << "A<string>" << endl;
}
template<>//对类A的成员特化
string A<string>::hum (string t) /*throw ()*/ {
cout << "A<string>::hum(string)" << endl;
return t;
}
int main (void) {
cout << ::max (123, 456) << endl;
cout << ::max ("hello", "world") << endl;
/*
cout << ::max<string> ("hello", "world")
<< endl;
cout << ::max (string ("hello"),
string ("world")) << endl;
*/
cout << Comparator<int> (123, 456).max ()
<< endl;
cout << Comparator<char const*> ("hello",
"world").max () << endl;
A<double>::foo ();
A<int>::bar (123, 456);
A<string>::foo ();
A<string>::hum ("abc");
return 0;
}

tips:成员特化的声明为通用版本和特化版本所共享，因此特化实现除了类型参数以外的接口规格(返回类型、函数名、形参表、常属性、异常说明)必须和通用版本完全一致。

3)局部特化(偏特化)

定义一个关于类模板的特化实现，该实现只针对该模板部分类型参数取特定类型，或者类型参数之间具有某种特定关系或属性。

#include <iostream>
using namespace std;
template<typename A, typename B>
class X {
public:
static void foo (void) {
cout << "X<A,B>" << endl;
}
};
template<typename A> //X的局部特化
class X<A, short> {
public:
static void foo (void) {
cout << "X<A,short>" << endl;
}
};
template<>
void X<int, double>::foo (void) {
cout << "X<int,double>::foo" << endl;
}
/*
// 局部特化不能只针对成员函数进行，
// 而必须针对整个类模板
template<typename A>
void X<A, double>::foo (void) {
cout << "X<A,double>::foo" << endl;
}*/
template<typename A>
class X<A, A> {
public:
static void foo (void) {
cout << "X<A,A>" << endl;
}
};
template<typename A, typename B>
class X<A*, B*> {
public:
static void foo (void) {
cout << "X<A*,B*>" << endl;
}
};
template<typename A>
class X<A*, A*> {
public:
static void foo (void) {
cout << "X<A*,A*>" << endl;
}
};
template<typename A, typename B>
class X<A&, B&> {
public:
static void foo (void) {
cout << "X<A&,B&>" << endl;
}
};
template<typename A, typename B>
class X<A[], B[]> {
public:
static void foo (void) {
cout << "X<A[],B[]>" << endl;
}
};
template<typename A, typename B> //函数模板
void foo (void) {
cout << "foo<A,B>" << endl;
}
template<>      //函数模板的全特化
void foo<int, short> (void) {
cout << "foo<int,short>" << endl;
}
/*
// 函数模板只能做完全特化，不能做局部特化
template<typename A>
void foo<A, short> (void) {
cout << "foo<A,short>" << endl;
}
*/
int main (void) {
X<int, double>::foo ();
X<int, short>::foo ();
X<int, int>::foo ();
X<int*, short*>::foo ();
X<int*, int*>::foo ();
X<int&, short&>::foo ();
X<int[], short[]>::foo ();
foo<char, double> ();
foo<int, short> ();
//  foo<char, short> ();
return 0;
}
// 全类特化既可以是完全特化，也可以是局部特化
// 成员特化只可能是完全特化，不可能是局部特化

四、模板的缺省参数

类模板的模板参数可以带有缺省值，实例化该模板时，如果没有提供模板实参，则相应的模板形参取缺省值。

#include <iostream>
#include <typeinfo>
using namespace std;
template<typename A = char, typename B = int,
typename C = double>
class X {
public:
X (A const& a, B const& b, C const& c) :
m_a (a), m_b (b), m_c (c) {}
void foo (void) const {
cout << typeid (m_a).name () << ": "
<< m_a << endl;
cout << typeid (m_b).name () << ": "
<< m_b << endl;
cout << typeid (m_c).name () << ": "
<< m_c << endl;
}
private:
A m_a;
B m_b;
C m_c;
};
template<typename A = char, typename B = int,
typename C = double>
void foo (A const& a, B const& b, C const& c) {
cout << typeid (a).name () << ": " << a << endl;
cout << typeid (b).name () << ": " << b << endl;
cout << typeid (c).name () << ": " << c << endl;
}
/*
void bar (int x, int y = x) {
cout << x << ' ' << y << endl;
}
*/
template<typename A, typename B = A>
void bar (void) {
cout << typeid (A).name () << ' '
<< typeid (B).name () << endl;
}
int main (void) {
X<char, int, double> x1 ('A', 123, 4.56);
x1.foo ();
X<char, int> x2 ('A', 123, 4.56);
x2.foo ();
X<char> x3 ('A', 123, 4.56);
x3.foo ();
X<> x4 ('A', 123, 4.56);
x4.foo ();
cout << "-------" << endl;
foo<char, int, double> ('A', 123, 4.56);
foo<char, int> ('A', 123, 4.56);
foo<char> ('A', 123, 4.56);
foo<> ('A', 123, 4.56);
foo (4.56, 123, 'A');
//  缺省参数：A/B/C -> char/int/double
//  隐式推断：A/B/C -> double/int/char <- 以此为准
//  bar (100);
bar<string> ();
return 0;
}

tips:

1).如果某个模板参数带有缺省值，那么它后面的所有模板参数必须都带有缺省值。

2).函数模板在C++2011标准以前不能带有缺省参数，但在该标准以后可以，其作用与类模板一致。

3).对于函数模板的类型参数，当隐式推断的结果与该参数的缺省值不一致时，以隐式推断为准。

4)函数模板的调用参数(圆括号中的参数)无论是98标准还是11标准都可以带有缺省值。

5)可以用前面的模板参数作为后面的模板参数的缺省值。

五、模板的非类型参数

1.模板的参数除了类型参数以外，也可以是数值形式的参数，与类型参数不同，模板的非类型参数不能用typename关键字声明，而必须使用具体类型，如int、unsigned int等。

2.传递给模板的非类型参数的实参只能是常量、常量表达式、带有常属性(const)的变量，但是不能同时带有挥发性(volatile)。

3.编译器的实现对模板非类型参数的限制

1)模板的非类型参数不能是浮点形式的。

2)模板的非类型参数不能是类类型的。

3)如果希望向模板传递字符串形式的非类型参数，其形参只能使用指针而不能是string，因为string是类类型，而且所传递的实参必须是没有static特性的全局字符数组。

include <iostream>
using namespace std;
class Integer {
public:
Integer (int i) : m_i (i) {};
int m_i;
};
ostream& operator<< (ostream& os,
Integer const& i) {
return os << i.m_i;
}
template<int/*double*//*float*//*Integer*/ x>
int/*double*//*float*//*Integer*/ square (void) {
return x * x/*Integer (x.m_i * x.m_i)*/;
}
template</*string*/char const* s>
void foo (void) {
cout << s << endl;
}
//char const* global = "abc";
/*static*/char array[] = "abc";
int main (void) {
cout << square<4/*4.0*//*4.0f*/
/*Integer (4)*/> () << endl;
//  char const* local = "abc";
//  char array[] = "abc";
foo</*"abc"*//*local*/array/*global*/> ();
return 0;
}

六、模板关键字的其它语义

1)typename解决嵌套依赖——访问依赖于模板参数的类型的内部类型。

在第一次编译模板代码时，模板参数的具体类型尚不明确，编译器会把依赖于模板参数的嵌套(内部)类型理解为某个类的静态成员变量。因此当它看到代码中使用这样的标识符声明其它变量时，会报告错误。typename关键字可以告诉编译器，所引用的标识符是个类型名，可以声明变量，具体类型等到实例化该模板(第二次编译)时再确定。

struct \

class - 声明类

\ 声明模板的

/ 类型参数

#include <iostream>
using namespace std;
class A {
public:
typedef unsigned int UINT;
class B {};
};
template<typename T>
void foo (void) {
typename T::UINT u;
typename T::B b;
}
int main (void) {
A::UINT u;
A::B b;
foo<A> ();
return 0;
}

2)template访问依赖于模板参数的模板型成员。

在模板代码中，通过依赖于模板参数的对象、引用或指针，访问其带有模板特性的成员，编译器常常因为无法正确理解模板参数列表的左右尖括号，而报告错误。在所引用模板名前面加上template关键字，意在告诉编译器其后的名称是一个模板，编译器就可以正确理解”<>”了。

#include <iostream>
#include <typeinfo>
using namespace std;
class A {
public:
// 模板型成员函数
template<typename T>
void foo (T t) const {
cout << "A::foo(" << typeid (t).name ()
<< ")" << endl;
}
};
template<typename T>
void bar (T const& t) {
t.template foo<string> ("1");
T const* p = &t;
p->template foo<string> ("1");
}
int main (void) {
A a;
a.foo (123);
a.foo (1.2);
a.foo ('1');
a.foo ("1");
a.foo<string> ("1");
bar (a);
return 0;
}

七、从模板形式基类中继承

1.如果基类是模板，那么子类必须也是模板，基类的模板参数通过子类的模板参数传递。

2.在子类模板中访问从基类模板中继承的成员，需要通过作用限定或者this指针显式指明，否则编译器只会在子类的作用域和全局作用域查找所引用的标识符。

#include <cstdlib>
#include <iostream>
using namespace std;
template<typename T>
class A {
public:
int m_var;         // 成员变量
void fun (void) {} // 成员函数
class B {};        // 成员类型
void exit (int status) {
cout << "再见！" << endl;
}
};
template<typename T>
class C : public A<T> {
public:
void foo (void) {
//      A<T>::m_var = 100;
this->m_var = 100;
//      A<T>::fun ();
this->fun ();
typename A<T>::B b;
A<T>::exit (0);
}
};
int main (void) {
C<int> c;
c.A<int>::m_var = 200;
c.A<int>::fun ();
C<int>::B b;
c.foo ();
return 0;
}

八、类模板的模板型成员

1.模板型成员变量

#include <iostream>
using namespace std;
template<typename T>
class A {
public:
A (T const& t) : m_t (t) {}
T m_t;
};
template<typename T>
class B {
public:
B (T const& t) : m_a (t) {}
A<T> m_a; // 模板型成员变量
};
int main (void) {
B<int> b (100);
cout << b.m_a.m_t << endl;
span class="hljs-keyword">return 0;
}

2.模板型成员函数

#include <iostream>
using namespace std;
template<typename A>
class X {
public:
X (A const& a) : m_a (a) {}
// 模板型成员函数
/*
template<typename B>
void foo (B const& b) const {
cout << m_a << ' ' << b << endl;
}*/
template<typename B>
void foo (B const& b) const;
private:
A m_a;
};
template<typename A>
template<typename B>
void X<A>::foo (B const& b) const {
cout << m_a << ' ' << b << endl;
}
int main (void) {
X<int> x (123);
x.foo (4.56);
return 0;
}

3.模板型成员类型

#include <iostream>
using namespace std;
template<typename A>
class X {
public:
X (A const& a) : m_a (a) {}
A m_a;
// 模板型成员类型(类模板的内部类模板)
/*
template<typename B>
class Y {
public:
Y (B const& b) : m_b (b) {}
B m_b;
};
*/
template<typename B>
class Y;
};
template<typename A>
template<typename B>
class X<A>::Y {
public:
Y (B const& b) : m_b (b) {}
B m_b;
};
int main (void) {
X<int> x (123);
cout << x.m_a << endl; // 123
X<int>::Y<double> y (4.56);
cout << y.m_b << endl; // 4.56
cout << sizeof (x) << ' ' << sizeof (y)
<< endl; // 4 8
return 0;

九、模板型模板参数

template<T> class Array { ... };
template<T> class List { ... };
template<T, template<typename> class C = List>
class Stack {
public:
void push (T const& data) {
m_c.push_back (data);
}
void pop (void) {
m_c.pop_back ();
}
T& top (void) {
return m_c.back ();
}
T const& top (void) const {
return const_cast<Stack*> (this)->top ();
}
private:
C<T> m_c;
};
Stack<int, Array> sia;
Stack<string, List> ssl;
Stack<double> sdl;

十、零初始化

类型参数 对象 = 类型参数 ();

如：T t = T ();

如果用类类型实例化模板参数T，则用该类的缺省构造函数初始化t；

如果用基本类型实例化模板参数T，则用相应类型的0初始化t。

#include <iostream>
using namespace std;
template<typename T>
void foo (void) {
T t = T (); // 零初始化语法
//  int t = int ();
//  string t = string ();
//  Student t = Student ();
cout << '[' << t << ']' << endl;
}
template<typename T>
class A {
public:
A (void) : m_t () { /*m_t = T ();*/ }
T m_t;
};
class Student {
public:
Student (string const& name = "学生",
int age = 20) : m_name (name), m_age (age){}
friend ostream& operator<< (ostream& os,
Student const& student) {
return os << student.m_name << ','
<< student.m_age;
}
private:
string m_name;
int m_age;
};
int main (void) {
foo<int> ();
foo<string> ();
foo<Student> ();
A<int> ai;
cout << '[' << ai.m_t << ']' << endl;
A<string> as;
cout << '[' << as.m_t << ']' << endl;
A<Student> at;
cout << '[' << at.m_t << ']' << endl;
return 0;
}

十一、类模板与虚函数

1.类模板中可以定义虚函数，只要保证其实例化类满足虚函数覆盖的条件，同样可以表现出多态特性。

2.虚函数本身不能又是模板函数。

#include <iostream>
using namespace std;
template<typename T>
class A {
public:
virtual void foo (T const& t) const {
cout << "A::foo: " << t << endl;
}
};
template<typename U, typename T>
class B : public A<U> {
public:
void foo (T const& t) const {
cout << "B::foo: " << t << endl;
}
};
/*
class C {
public:
template<typename T>
virtual void foo (T const& t) const {
cout << "C::foo: " << t << endl;
}
};*/
int main (void) {
B<int, int> b1;
A<int>& a1 = b1;
a1.foo (123);         //123
B<int, double> b2;
A<int>& a2 = b2;
a2.foo (4.56);  //4
return 0;
}