目录
泛型编程
如何实现一个通用的交换函数？
使用函数重载可以实现，但是有以下几个不好的地方：
1、重载的函数只是类型不同，代码的复用率比较低，只要有新类型出现时，就需要增加对应的函数。
2、代码的可维护性比较低，一个出错可能所有的重载均出错。
那能否告诉编译器一个模子，让编译器根据不同的类型利用该模子来生成代码呢：答案就是模板，分为函数模板和类模板。
泛型编程：编写与类型无关的通用代码，是代码复用的一种手段。模板是泛型编程的基础。
函数模板：
概念：
函数模板代表了一个函数家族，该函数模板与类型无关，在使用的时候被参数化，根据实参类型产生函数的特定类型版本。
格式：
template<typename T1, typename T2,..., typename Tn>
返回值类型 函数名（参数列表）{}
交换函数的模板：
template<typename T>
void Swap(T& left, T& right) {
T temp = left;
left = right;
right = temp;
}
typename是用来定义模板参数的关键字，也可以使用class，但是不能使用struct。
函数模板原理：
函数模板是一个蓝图，它并不是函数，是编译器根据使用方式产生特定具体类型函数的模具。本质上就是将本来由我们做的事交给了编译器。
在编译器编译阶段，对于模板函数的使用，编译器需要根据传入的实参类型来推演生成对应类型的函数以供调用。
三个函数对应的函数入口地址均不一样，说明这是三个相互独立的函数，它们都是编译器根据参数类型和函数模板推演出来的函数。
函数模板的实例化：
用不同类型的参数使用函数模板时，称为函数模板的实例化。具体分为隐式实例化和显示实例化。
隐式实例化：
template<class T>
T Add(const T& left, const T& right) {
return left + right;
}
int main()
{
int a1 = 10, a2 = 20;
double d1 = 10.0, d2 = 20.0;
Add(a1, a2);
Add(d1, d2);
Add(a1, d1);
/*
该语句不能通过编译，因为在编译期间，当编译器看到该实例化时，需要推演其实参类型
通过实参a1将T推演为int，通过实参d1将T推演为double类型，但模板参数列表中只有一个T，
编译器无法确定此处到底该将T确定为int 或者 double类型而报错
注意：在模板中，编译器一般不会进行类型转换操作，因为一旦转化出问题，编译器就需要背黑锅
Add(a1, d1);
*/
// 此时有两种处理方式：1. 用户自己来强制转化 2. 使用显式实例化
Add(a1, (int)d1);
return 0;
}显示实例化：
int main(void) {
int a = 10;
double b = 20.0;
// 显式实例化
Add<int>(a, b);
return 0;
}模板参数的匹配原则：
1、一个非模板参数可以和一个同名的函数模板同时存在，而且该函数模板还可以被实例化为这个非模板函数。
2、对于非模板函数和同名函数模板，如果其他条件都相同，在调用时会优先调用非模板函数，而不会从从该模板产生出一个实例。如果模板可以产生一个具有更好匹配度的函数，那么将先择模板。
// 专门处理int的加法函数
int Add(int left, int right) {
return left + right;
}
// 通用加法函数
template<class T1, class T2>
T1 Add(T1 left, T2 right) {
return left + right;
}
void Test(){
Add(1, 2); // 与非函数模板类型完全匹配，不需要函数模板实例化
Add(1, 2.0); // 模板函数可以生成更加匹配的版本，编译器根据实参生成更加匹配的Add函 数
}
int main() {
Test();
3、函数模板不允许自动类型转化，但普通函数可以进行自动类型转化。
类模板
格式：
template<class T1, class T2, ..., class T3>
class 类模板名{
}
动态顺序表的实现 ：
//动态顺序表
template<class T>
class Vector {
public:
Vector(size_t capacity = 10)
:_pDate(new T[capacity])
,_size(0)
,_capacity(capacity){
}
//使用析构函数演示，在类中声明，类外定义。
~Vector();
void PushBack(const T& data) {
if (_capacity == _size) {
//扩容
ExpandCapicity();
}
_pDate[_size++] = data;
}
void popBack() {
if (isEmpaty()) {
return;
}
_size--;
}
T& GetFront()const {
return _pDate[0];
}
T& GetBack()const {
return _pDate[_size - 1];
}
size_t GetSize()const {
return _size;
}
bool isEmpaty()const {
return _size == 0;
}
private:
void ExpandCapicity() {
size_t newcapacity = _capacity * 2;
T* temp = new T[newcapacity];
memcpy(temp, _pDate, sizeof(T) * _size);
delete[] _pDate;
_pDate = temp;
_capacity = newcapacity;
}
private:
T* _pDate;
size_t _size;
size_t _capacity;
};
// 注意：类模板中函数放在类外进行定义时，需要加模板参数列表
template<class T>
Vector<T>::~Vector() {
if (_pDate) {
delete[] _pDate;
}
_size = _capacity = 0;
}注意：
1、类模板名是一个类名，并不是类型，不能用来实例化对象。要实例化对象需要用类模板名<具体类型>来进行实例化。
2、类模板中的函数若在类外定义，需要加上模板参数列表，并且需要加上所属类和作用域限定符。
非类型参数模板
模板参数分为两大类：
类型形参：出现在模板参数列表中，跟在class或者typename之后的参数类型名称。
非类型形参：用一个常量作为类（函数）模板的一个参数，在类（函数）模板中可以将该参数当作常量使用。
静态顺序表：
// 定义一个模板类型的静态数组
template<class T, size_t N = 10>
class Array{
public:
Array() {
_size = 0;
}
T& operator[](size_t index) { //this指针指向的是一个变量
return _array[index];
}
const T& operator[](size_t index)const { //this指针指向的是一个常量
return _array[index];
}
size_t size()const {
return _size;
}
bool empty()const {
return 0 == _size;
}
private:
T _array[N];
size_t _size;
};
int main() {
Array<int,20> arr;
const Array<int,20> a(arr);
arr[0] = 1;
arr[15] = 3;
cout << arr[15] << endl;
cout << a[15] << endl;
}
#endif注意：
1、浮点数、类对象以及字符串是不允许作为非类型模板参数的。
2、非类型的模板参数必须在编译期就能确认结果。
模板的特化
通常情况下，使用模板可以实现与类型无关的代码，但对于一些特殊类型的可能会得到一些错误的结果，此时就需要进行模板特化。所谓模板特化就是在原来模板的基础之上，针对特殊类型所进行特殊化的方式。模板特化分为两类：1、函数模板特化。2、类模板特化。
函数模板特化：
步骤 ：
1、必须有一个基础的函数模板
2、关键字template后面跟着一对空的尖括号<>
3、函数名后跟一对尖括号，尖括号中指定需要的类型
4、函数形参表：必须要和模板函数的基础参数类型完全相同 ，如果不同编译器可能会出现一些奇怪的错误。
可以看到结果错误。由两种解决办法：
1、给出函数模板的特化：
template<>
bool IsEqual<const char* const>(const char* const & left ,const char* const & right) {
if (strcmp(left, right) > 0)
return true;
return false;
}2、针对无法处理的类型直接给出的处理函数
bool IsEqual(const char* left, const char* right) {
return strcmp(left, right) == 0;
}这个不是函数模板的特化，只是针对无法处理的类型给出的处理函数。
注意：
一般情况下如果函数模板遇到不能处理或者处理有误的类型，为了实现简单，通常就是将该函数直接给出。
类模板的特化：
全特化：
将模板参数列表中所有的参数都确定化。
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:
Data() { cout << "Data<int, char>" << endl; }
private:
int _d1;
char _d2;
};
void TestVector(){
Data<int, int> d1; //通过默认的类模板创建一个类对象
Data<int, char> d2; //按照全特化的类模板来创建对象
}偏特化：
任何针对模板参数进一步进行条件限制设计的特化版本都属于偏特化。有两种：
1、部分特化，将模板参数中一部分参数特化：
// 将第二个参数特化为int
template <class T1>
class Data<T1, int> {
public:
Data() {cout<<"Data<T1, int>" <<endl;}
private:
T1 _d1;
int _d2;
};2、参数更进一步限制
偏特化并不仅仅是特化部分参数，而是针对模板参数更进一步的条件限制所设计出来的一个特化版本。
template <typename T1, typename T2>
class Data {
public:
Data() { cout << "Data<T1*, T2*>" << endl; }
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, const T2& d2)
: _d1(d1)
, _d2(d2) {
cout << "Data<T1&, T2&>" << endl;
}
private:
const T1 & _d1;
const T2 & _d2;
};
void test2()
{
Data<int, double> d2; // 调用基础的模板
Data<int *, int*> d3; // 调用特化的指针版本
Data<int&, int&> d4(1, 2); // 调用特化的指针版本
}模板的分离编译过程
分离编译：
一个程序（项目）由若干个源文件同时实现，而每个源文件单独编译生成目标文件，最后将所有目标文件链接起来形成单一的可执行文件的过程。
模板的分离编译：
假如有以下场景，模板的声明和定义分开：
可以看到报错了。
现在在test.cpp中实例化一下，就发现可以编译通过。
现象：在定义模板的源文件内实例化过的Add函数，在其他源文件内可以正常使用。未实例化的就不能正常使用。
原因：
本质上是因为每个源文件都是单独编译的！对于该文件中未定义并且使用到的函数（变量）地址，会在链接的时候通过重定位来找到这些地址。如果找到了，就不会报错；找不到就会报错。
解决办法：
1、将声明和定义放在一个文件“xxx.hpp”里面或者“xxx.h”里面（推荐使用，一般放在.hpp中）
2、模板定义的位置显示实例化（不实用，不推荐使用）
模板总结：
优点;
1、模板复用了代码，节省资源，更快的迭代开发，C++的标准模板库（STL）因此而产生
2、增强了代码的灵活性
缺点：
1、模板会导致代码膨胀问题，也会导致编译时间变长
2、出现模板编译错误时，错误信息非常凌乱，不易定位错误。
611
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
