C++11：模板（可变模板参数）_c++ 模板参数包 使用

模板

1、产生背景

为了解决强类型语言的严格性与灵活性的冲突，将类型抽象

• 带参数的宏定义(原样替换)
• 函数重载(函数名字相同，参数不同)
• 模板(将数据类型作为参数)

语言类型

• 强类型语言：C++/C/Java，有类型定义，能进行类型安全检查，编译型语言，安全但不灵活
• 弱类型语言：js/python，没有严格的类型，解释型语言，错误留到运行时，灵活但不安全

2、模板的特征

模板的定义形式

template <class/typename T>
1

模板的类型

• 函数模板
• 类模板

2.1、函数模板

template <模板参数表> //模板参数列表不能为空
返回类型 函数名（参数列表）
 { 函数体 }

template <class T>  
T func(T t)
1
2
3
4
5
6

函数模板通过**模板参数推导(实例化)**为模板函数。

// 隐式实例化：编译器自动推导。
cout << add(i1, i2) << endl; // 由i1,i2都是int，自动生成函数 int add(int,int)
// 显式实例化
cout << add<double>(d1, d2) << endl;
1
2
3
4

函数模板与普通函数间的关系

• 函数模板可以与普通函数进行重载，而且普通函数优先于函数模板执行
• 函数模板与函数模板间也是可以进行重载的

模板的特化：统一的函数模板不能适用的类型时，模板在特定类型下的实现，。

• 偏特化：特化部分参数。
• 全特化：特化所有参数。函数模板只有全特化。

#include <string.h>
#include <iostream>
using std::cout;
using std::endl;

template <class T>
T add(T x, T y)
{
	cout << "T add(T,T) " << endl;
	return x + y;
}

//模板的全特化，是函数模板。也可以函数重载，普通的函数
template <>
const char * add<const char *>(const char * px, const char * py)
{
	char * ptmp = new char[strlen(px) + strlen(py) + 1]();
	strcpy(ptmp, px);
	strcat(ptmp, py);
	return ptmp;
}

int main() {
	const char * ps1 = "hello";
	const char * ps2 = "world";

	const char * pstr = add(ps1, ps2);
	cout << pstr << endl;
	delete pstr;

	int i1 = 1, i2 = 2;
	double d1 = 1.1, d2 = 2.2;
	cout << add(i1, i2) << endl;
	cout << add(d1, d2) << endl;
    
    return 0
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

模板头文件与实现文件

C++头文件都是使用模板进行编写的，而模板的的特点是必须知道所有实现才能进行正常编译。。模板不能将声明与实现分开，模板的类型是 inline 函数。模板的运行机制是在编译时，通过实参传递时，进行参数推导。当头文件与实现文件分离时，实现文件中没有函数的调用，所以在编译时并不会进行参数推导，没有函数的产生。

函数声明与实现分离：

#ifndef __ADD_H__
#define __ADD_H__

template <class T>
T add(T x, T y);
 
#include "add.tcc" //实现函数声明与实现分离
#endif
1
2
3
4
5
6
7
8

模板的参数类型

• 类型参数，class T
• 非类型参数，常量表达式，即整型 bool/char/short/int/long(float, double不行)

#include <iostream>
using std::cout;
using std::endl;

template <class T, int kBase=10> //double报错
T multiply(T x, T y)
{
	return x * y * kBase;
}

void test0()
{
	int i1 = 10, i2 = 11;
	//常量的传递是在函数调用时完成的
	cout << multiply<int, 10>(i1, i2) << endl;
	cout << multiply<int, 20>(i1, i2) << endl;
	cout << multiply(i1, i2) << endl; // 若没有给int给默认参数，则无法推导报错
}

int main(){
	test0();
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

成员函数模板

class Point 
{
public: 
    template <typename T = int> 
    T func() 
    { 
        return (T)_dx; 
    } 
private: 
    double _dx; 
    double _dy; 
};
1
2
3
4
5
6
7
8
9
10
11
12

2.2、类模板

注意类模板的嵌套，一层一层写，成员函数类外定义必须加上模板参数列表。

#include <string>
#include <iostream>
using std::cout;
using std::endl;
using std::string;

template <class T, size_t kSize =10>
class Stack 
{
public:
	Stack()
	: _top(-1)
	, _pdata(new T[kSize]())
	{}

	~Stack();

	T top() const;
	bool empty() const;
	bool full() const;
	void push(const T & t);
	void pop();

private:
	int _top;
	T * _pdata;
};
 
//如果是类模板，其成员函数在类外定义时，必须加上模板参数列表
template <class T, size_t kSize>
Stack<T,kSize>::~Stack()
{
	if(_pdata) {
		delete [] _pdata;
	}
}

template <class T, size_t kSize>
T Stack<T, kSize>::top() const
{
	return _pdata[_top];
}

template <class T, size_t kSize>
bool Stack<T, kSize>::empty() const
{
	return _top == -1;
}

template <class T, size_t kSize>
bool Stack<T, kSize>::full() const
{
	return  (kSize - 1) == _top;
}

template <class T, size_t kSize>
void Stack<T, kSize>::push(const T & t)
{
	if(full()) {
		cout << "stack is full, cannnot push data any more!" << endl;
	} else {
		_pdata[++_top] = t;
	}
}

template <class T, size_t kSize>
void Stack<T, kSize>::pop()
{
	if(empty()) {
		cout << "stack is empty, no data!" << endl;
	} else {
		--_top;
	}
}

void test1()
{
	Stack<string> stack;
	cout << "此时栈是否为空? " << stack.empty() << endl;
	stack.push(string(2, 'a'));
	cout << "此时栈是否为空? " << stack.empty() << endl;
	cout << stack.top() << endl;

	for(int idx = 1; idx < 11; ++idx) {
		stack.push(string(2, 'a' + idx));
	}

	cout << "此时栈是否已满? " << stack.full() << endl;
	while(!stack.empty()) {
		cout << stack.top() << endl;
		stack.pop();
	}
	cout << "此时栈是否为空? " << stack.empty() << endl;
}
 
int main(void)
{
	test1();
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100

3、可变模板参数

C++ 11 新特性，对参数进行了高度的泛化，可表示0到任意个数、任意类型的参数。

• 模板参数包 Args：可以接受任意多个参数作为模板参数

  template <typename... Args>
  1

• 函数参数包 args：函数可以接受多个任意类型的参数。要求函数参数包必须唯一，且是函数的最后一个参数。

  template<typename... T> 
  void f(T... args)
  1
  2

省略号的作用

• 位于参数左边：打包 T... args
• 位于参数右边：解包 args...

获取可变模板参数的个数

sizeof...(Args)
sizeof...(args)
1
2

3.1、可变模板参数的展开

• 通过递归函数来展开参数包
• 是通过逗号表达式来展开参数包。

3.1.1、通过递归函数展开参数包

参数包在展开的过程中递归调用自己，每调用一次参数包中的参数就会少一个，直到所有的参数都展开为止，当没有参数时，则调用递归终止函数终止递归过程。

#include <iostream>

using namespace std;

//递归终止函数
void print() {
	cout << endl;
}

//展开函数
template <class T, class ...Args>
void print(T head, Args... rest) {
	cout  << head << " ";
    // 调用过程，对参数包的展开过程
	print(rest...);
}

//递归终止函数
template<typename T>
T sum(T t) {
	return t;
}

//展开函数
template<typename T, typename ... Types>
T sum(T first, Types ... rest) {
	return first + sum<T>(rest...);
}

int main() {
	print(1, 2, 3, "hello", "world");
	cout << sum(1, 2, 3, 4) << endl; //10

	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

3.1.2、通过逗号表达式展开参数包

逗号表达式：表达式1, 表达式2，先执行表达式1，再执行表达式2，返回的结果只与表达式2有关。利用初始化列表来初始化变长数组，在数组构造的过程中展开参数。

#include <iostream>
using namespace std;

// 1、处理参数包中每一个参数的函数
template <class T>
void printarg(T t) {
    cout << t << endl;
}

// 2、展开参数包
template <class ...Args>
void expand(Args... args) {
    // 先执行printarg(args)展开参数包并打印参数，再执行逗号表达式得到结果0
    // 1、int arr[] = {(printarg(1), 0), (printarg(2), 0), (printarg(3), 0)} 
    // 2、int arr[] = {0, 0 ,0}
    int arr[] = {(printarg(args), 0)...};
}

int main() {
    expand(1, "hello", 3);
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

将函数作为参数，改写成 lambda 表达式

#include <iostream>
using namespace std;

template<class F, class... Args>
void expand(const F& f, Args&&...args) {
	//std::initializer_list 接收任意长度的初始化列表，这里用到了完美转发
	initializer_list<int>{(f(std::forward< Args>(args)), 0)...};
}

int main() {
    // 只能参数列表中类型的参数
	expand([](int i) { cout << i << endl; }, 1, 2, 3);
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14