【C++】template模板：泛型编程_template

1. 泛型编程

告诉编译器一个模板，让编译器根据不同的类型利用该模板生成代码。
泛型编程：编写与类型无关的通用代码，是代码复用的一种手段。
模板是泛型编程的基础。

2. 函数模板

函数模板代表了一个函数家族，该函数模板与类型无关，在使用时被参数化，根据实参类型产生函数的特定类型版本。

2.1.函数模板格式

1. 单参数：
   template<class T>
template<typename T>
2. 多参数：
   template<class T1, calss T2>
template<typename T1, tupename T2>
   T为类型模板参数，就当成普通的类型使用
   (typename是用来定义模板参数关键字，也可以使用class)

template<class T>
template<typename T>
//calss/typename两种方法，二选一即可
void Swap( T& left, T& right)
{
T temp = left;
left = right;
right = temp;
}
//T1、T2为类型模板参数，就当成普通的类型使用
//只是针对广泛的类型变成，而不是某一个类型(通用类型)
1
2
3
4
5
6
7
8
9
10
11

---

函数模板的原理：
在编译器编译阶段，对于模板函数的使用，编译器需要根据传入的实参类型来推演生成对应类型的函数以供调用。
比如：
当用double类型使用函数模板时，编译器通过对实参类型的推演，将T确定为double类型，然后产生一份专门处理double类型的代码。

2.2.函数模板的实例化

用不同类型的参数使用函数模板时，称为函数模板的实例化。
(实例化函数)

1. 隐式实例化：让编译器根据实参推演模板参数的实际类型

template<class T>
T Add(const T& left, const T& right)
{
    return left + right;
}
int main()
{
    int a1 = 1, a2 = 2;
    double d1 = 1.11, d2 = 2.22;
    Add(a1, a2);//编译器自动判断类型实例化函数
    Add(d1, d2);//编译器自动判断类型实例化函数
    Add(a1, d2);//编译不通过，只有一个T，只能实例化一种类型的函数
    Add(a1, (int)d2);//参数强转为同类型可以通过
    return 0;
1
2
3
4
5
6
7
8
9
10
11
12
13
14

2. 显式实例化：在函数名后的<>中指定模板参数的实际类型。
   如果类型不匹配，编译器会尝试进行隐式类型转换，如果无法转换成功编译器将会报错。

int main(void)
{
int a = 10;
double b = 20.0;
// 显式实例化
Add<int>(a, b);
return 0;
}
1
2
3
4
5
6
7
8

---

3. 类型模板参数

类模板一般要显式实例化，因为传参不一定传模板参数。

template<class T>
class Stack
{
public:
	Stack(int capacity = 4)
	{
		_a = new T(capacity);
		_capacity = capacity;
		_size = 0;
	}
	~Stack()
	{
		delete[] _a;
		_capacity = _size = 0;
	}
private:
	T* _a;
	size_t _size;
	size_t _capacity;
};

int main()
{
	//实例化的时候调用构造函数，而构造函数传参为capacity，
	//没有给T*类型的指针_a传参，所以要手动规定T的类型。
	//显式实例化
	Stack<int> st1; 
	Stack<double> st2;
	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

---

补充：
1.类名与类型：
之前定义的时候，类名就是类型，可以直接定义，比如Date d1;，引入类模板以后，类名和类型要区分开。比如Date就是类名，而不是类型，类型要加上模板参数：Date<int> d1;

2.类模板函数声明定义分离：
之前在类中定义，类外声明，定义直接写为

Date::~Date()
{
    _year = _month = _day = 0;
}
1
2
3
4

类模板的声明定义分离，定义则要写为：

//不能只指定类名，模板参数T也要加上，要加模板参数T就要加上声明模板参数templant<class T>
templant<class T>
Date<T>::~Date()
{
    _year = _month = _day = 0;
}
1
2
3
4
5
6

3.类模板声明定义分离不能分别写在头文件和源文件中，会出现链接错误，就算要分离也得写在一个文件中。（之后有解决方法）

---

4. 非类型模板参数

模板参数分类类型形参与非类型形参。

• 类型形参：出现在模板参数列表中，跟在class或者typename之类的参数类型名称。
• 非类型形参：就是用一个常量作为类(函数)模板的一个参数，在类(函数)模板中可将该参数当成常量来使用

注：

1. 非类型模板参数可以给缺省值。
2. 非类型模板参数只能是整形常量，浮点数、类对象以及字符串是不允许作为非类型模板参数的。
3. 非类型的模板参数必须在编译期就能确认结果。

template<class T, size_t N = 20>
calss Array
{
public:
private:
	T _a[N];
};

int main()
{
//要求实例化类型int的大小为10
//类型double的大小为10
	Array<int, 10> a1;	
	Array<double, 20> a2;

	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

5. 模板特化

模板特化：在原模板类的基础上，针对特殊类型所进行特殊化的实现方式。

模板特化分为：

1. 函数模板特化
2. 类模板特化

---

1.函数模板特化

函数模板的特化步骤：

1. 必须要先有一个基础的函数模板
2. 关键字template后面接一对空的尖括号<>
3. 函数名后跟一对尖括号，尖括号中指定需要特化的类型
4. 函数形参表: 必须要和模板函数的基础参数类型完全相同

特化格式例：

template<class T>
bool Less(T left, T right)
{
	return left < right;
}

// 对Less函数模板进行特化
template<>
bool Less<Date*>(Date* left, Date* right)
{
	return *left < *right;
}
1
2
3
4
5
6
7
8
9
10
11
12

注意：如果函数模板遇到不能处理或者处理有误的类型，为了实现简单通常都是将该函数直接给出。
一般直接用重载，不用函数模板特化。

---

2.类模板特化

1.类模板的特化步骤：

1. 必须要先有一个基础的类模板
2. 关键字template后面接一对空的尖括号<>（偏特化特殊规定）
3. 类名后跟一对尖括号，尖括号中指定需要特化的类型
4. 函数形参表: 必须要和模板函数的基础参数类型完全相同

2.类模板特化的分类：

1. 全特化：全特化即是将模板参数列表中所有的参数都确定化
2. 偏特化：任何针对模版参数进一步进行条件限制设计的特化版本。

全特化

全特化即是将模板参数列表中所有的参数都确定化。

全特化例：

template<class T1, class T2>
class Data
{
public:
	Data() 
	{
		cout<<"Data<T1, T2>" <<endl;
	}
private:
	T1 _d1;
	T2 _d2;
};

template<>
class Data<int, char>
{
public:

private:
	int _d1;
	char _d2;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

偏特化

任何针对模版参数进一步进行条件限制设计的特化版本。

偏特化有两种表现方式：

1. 部分参数特化：将模板参数类表中的一部分参数特化
2. 参数进一步限制：偏特化并不仅仅是指特化部分参数，而是针对模板参数更进一步的条件限制所设计出来的一个特化版本

1.部分参数特化例

template<class T1, class T2>
class Data
{
public:
	Data() 
	{
		cout<<"Data<T1, T2>" <<endl;
	}
private:
	T1 _d1;
	T2 _d2;
};

// 将第二个参数特化为int
template <class T1>
class Data<T1, int>
{
public:
	Data() 
	{
		cout<<"Data<T1, int>" <<endl;
	}
private:
	T1 _d1;
	int _d2;
};
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

2.参数更进一步的限制例

template<class T1, class T2>
class Data
{
public:

private:
	T1 _d1;
	T2 _d2;
};

//两个参数偏特化为指针类型
template <typename T1, typename T2>
class Data <T1*, T2*>
{
public:
	Data() 
	{
		cout<<"Data<T1*, T2*>" <<endl;
	}
private:
	T1 _d1;
	T2 _d2;
};

//两个参数偏特化为引用类型
template <typename T1, typename T2>
class Data <T1&, T2&>
{
public:
	Data(const T1& d1 = T1(), const T2& d2 = T2())
	: _d1(d1)
	, _d2(d2)
	{
		cout<<"Data<T1&, T2&>" <<endl;
	}
private:
	const T1 & _d1;
	const T2 & _d2;
};
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

6.模板的分离编译

分离编译：
一个程序由若干个源文件共同实现，而每个源文件单独编译生成目标文件，最后将所有目标文件链接起来形成单一的可执行文件的过程称为分离编译模式。

模板不支持分离编译，即模板不能声明与定义分离，会报链接错误！
（不能一个在.h，一个在.cpp）

1.原理：
在程序编译阶段，不同的源文件是分开编译的，在完成汇编后，链接阶段不同的源文件才合为一体，也就是只有在链接阶段不同的源文件才会发生交互，之前都是分开来单独预处理编译汇编的。
在编译好后，查看汇编代码，会发现生成的汇编代码中，不存在模板函数，没有模板函数的地址可以跳转，这是因为模板函数没有实例化，无法确定模板参数是什么类型的。但是又因为存在模板函数的声明，所以生成的汇编中会有call 模板函数(模板函数地址)，没有模板函数地址，暂时先空着，这时候编译器会认为模板函数的实现地址在其他的源文件中，就可以通过编译，在链接的时候才将其他源文件中的地址填入进去。但是此时模板函数没有地址的原因是因为没有实例化，其他源文件中也不存在模板函数地址，就会导致链接错误。（类模板也一样）

2.解决方法：

1. 将声明和定义放到一个文件 “xxx.hpp” 里面或者 “xxx.h” 其实也是可以的。（推荐）
2. 模板定义的位置显式实例化。这种方法不实用。（不推荐）

显式实例化的方式：
缺点就是每一个出现的类型都要手动实例化一份，模板就没有意义了！不好用！

template
int Add<int>(int& left, int& right);

template
double Add<double>(double& left, double& right);
1
2
3
4
5

---

3.问题思考：

• 那么对于第一种方法，我在学习时思考，都放在一个文件中了，为什么还需要声明定义分离？直接定义不就好了？
  因为对于函数模板，直接定义也可以。
  但是还有类模板，类模板需要声明定义分离，因为类中定义函数会变成内联函数，类模板中的函数在类内声明，类外定义。（短小的函数可以在类内直接定义为内联函数）

• 为什么声明定义放在一个文件中就不会出现链接错误了？
  因为在预处理时，.h会在出现的地方展开，此时展开以后，有函数声明，并且下面在调用的地方表明了所需要实例化的类型，即函数实例化了，所以会生成函数地址，就不用等到链接的时候再填入了，此时有地址直接就可以在编译时call 函数名 函数地址 了。
  即又有函数声明（函数名），又有函数实例化（函数地址），不需要链接填地址了。

• .h与.hpp本质上其实并没有很大的区别，只是在名字上表示出声明与定义都放在一起了，暗示用户这是个模板。