目录
一、泛型编程
C语言中，定义一个函数来交换两个变量的值，如果变量的类型有多种，那么函数也必要定义多个：
void Swapi(int* p1, int* p2)
{
int temp = *p1;
*p1 = *p2;
*p2 = temp;
}
void Swapd(double* p1, double* p2)
{
double temp = *p1;
*p1 = *p2;
*p2 = temp;
}
void Swapc(char* p1, char* p2)
{
char temp = *p1;
*p1 = *p2;
*p2 = temp;
}
int main()
{
int a = 1, b = 2;
Swapi(&a, &b);
double c = 1.1, d = 2.2;
Swapd(&c, &d);
char e = 'a', f = 'b';
Swapc(&e, &f);
return 0;
}由于c语言函数名修饰规则直接使用函数名生成符号表，不允许多个同名函数同时存在，多个函数名必须不同，因此只能写多个相似的swap函数，如果其他类型的变量也要进行交换，又得重新定义其他函数。C++支持函数重载，如果参数类型不同，多个函数可以使用同一个函数名：
void Swap(int& p1, int& p2)
{
int temp = p1;
p1 = p2;
p2 = temp;
}
void Swap(double& p1, double& p2)
{
double temp = p1;
p1 = p2;
p2 = temp;
}
void Swap(char& p1, char& p2)
{
char temp = p1;
p1 = p2;
p2 = temp;
}
int main()
{
int a = 1, b = 2;
Swap(a, b);
double c = 1.1, d = 2.2;
Swap(c, d);
char e = 'a', f = 'b';
Swap(e, f);
return 0;
}但是如果其他类型的变量也要进行交换，又得重新定义不同参数类型的函数重载，不断使用函数重载会有以下问题：
（1）重载的函数仅仅只是类型不同，代码的复用率比较低，只要有新类型出现时，就需要增加对应的函数
（2）代码的可维护性比较低，一个出错可能所有的重载均出错
能不能只写一个与类型无关的函数来适配所有参数类型捏？
比如给编译器一个模子，让编译器根据不同的类型用这个模子来生成代码。C++增加了泛型编程：编写与类型无关的通用代码，是代码复用的一种手段，模板是泛型编程的基础。
二、函数模板
1.函数模板概念
函数模板代表了一个函数家族，函数模板与类型无关，在使用时被参数化，根据实参类型产生函数的特定类型版本。
2.函数模板格式
template<typename T1,typename T2,,typename T3,typename T4,……,typename Tn>
返回值类型 函数名(参数列表){}typename是用来定义模板参数关键字，也可以使用class(千万不能使用struct)。
有了模板以后，交换函数可以这样写：
// 函数模板
template <typename T>
void Swap(T& t1, T& t2)
{
T temp = t1;
t1 = t2;
t2 = temp;
}
int main()
{
int a = 1, b = 2;
Swap(a, b);
double c = 1.1, d = 2.2;
Swap(c, d);
return 0;
}F10-调试-窗口-监视-F11，发现Swap(a, b);和Swap(c, d);都调用了 void Swap(T& t1, T& t2)函数：
3.函数模板原理
实际上Swap(a, b);和Swap(c, d); 调用的是一个函数还是两个函数呢？
F10-调试-窗口-反汇编，发现他们调用的两个不同的函数地址，也就是调用了两个不同的函数，说明经过编译器处理，进行了模板的实例化，方便调试：
原理：
如下图所示，模板不是函数，是编译器用来产生特定具体类型函数的模具，把本来应该是我们做的事交给了编译器：
编译器通过调用实参，去推演模板板的形参，就推出了T到底是double型、int型还是char型，并实例化生成3份代码。
预处理阶段推演出3份代码以后，中间的模板就不存在了，编译器把它转化成后面3个函数，再去调对应的这3个函数。
整个过程其实是我们自己偷了个懒，即本该由我们自己写这3个函数，但是我们不想重复写，就自己写了一个模板，编译器通过模板帮我们生成了对应的代码。
注意：如果有多个参数时，参数的类型不同就不能用模板，因为编译器不知道T到底要传给哪种类型。
比如，a是int型，c是double型，，模板参数只有一个T，T不知道要推演成int，还是推演成double：
Swap(a, c);//编译报错
模板参数还可以做返回值：
//函数模板
template <typename T>
T Add(T& t1, T& t2)//返回值类型是泛型
{
return t1 + t2;
}
int main()
{
int a = 1, b = 2;
Add(a, b);
double c = 1.1, d = 2.2;
Add(c, d);
return 0;
}4.函数模板的实例化
函数模板的实例化：用不同类型的参数使用函数模板。模板参数实例化分为隐式实例化和显式实例化。
（1）隐式实例化
隐式实例化就是让编译器根据实参推演函数模板参数的实际类型。如前所示，a和b同类型，都是int，编译器会根据Add函数传的实参推演模板参数的实际类型T：
#include<iostream>
using namespace std;
//函数模板
template <typename T>
T Add(T& t1, T& t2)//返回值类型是泛型
{
return t1 + t2;
}
int main()
{
int a = 1, b = 2;
Add(a, b);
double c = 1.1, d = 2.2;
Add(c, d);
return 0;
}以上就是隐式实例化。
但是如何让下面代码也编译通过呢？
Add(a,c);编译器不知道要将T推演成int还是推演成double，但是我们可以将参数进行强转，在编译器推演T的类型之前，将两个参数的类型强行转为同类型：
Add(a,(int)c);
Add((double)a, c);但是编译不通过：
这是因为强转会发生隐式类型转换，c是double型，强转为int型，中间会产生一个int类型的临时变量，而临时变量具有常性，Add函数的参数t1和t2没有使用const修饰，会导致权限放大，这是不允许的，因此要将Add函数的参数类型加上const关键字进行修饰：
template <typename T>
T Add(const T& t1, const T& t2)//返回值类型是泛型
{
return t1 + t2;
}
int main()
{
int a = 1, b = 2;
Add(a, b);
double c = 1.1, d = 2.2;
Add(c, d);
Add(a, (int)c);
Add((double)a, c);
return 0;
}为了让Add(a,c);编译通过，强转只是解决的一种方法，还有另外一种方法：显式实例化。
（2）显式实例化
显式实例化就是在函数名后的<>中指定模板参数的实际类型：
Add<int>(a, c);//a和c都将作为int型传给形参
Add<double>(a, c);//a和c都将作为double型传给形参如果类型不匹配，编译器会尝试进行隐式类型转换，如果无法转换成功，编译器会报错。
（3）模板参数的匹配原则
①一个非模板函数可以和一个同名的函数模板同时存在，该函数模板还可以被实例化为这个非模板函数：
int Add(int t1, int t2)//返回值类型是泛型
{
return t1 + t2;
}
template <typename T>
T Add(const T& t1, const T& t2)//返回值类型是泛型
{
return t1 + t2;
}
int main()
{
int a = 1, b = 2;
Add(a, b);
Add<int>(a, c);
return 0;
}F10-调试-窗口-反汇编：
发现Add(a,b)与非模板函数匹配，编译器不需要进行模板函数实例化：
发现Add<int>(a,c)调用函数模板，模板函数进行了实例化，生成了同名非模板函数：
②对于非模板函数和同名函数模板，如果其他条件都相同，在调动时会优先调用非模板函数而不会从该模板产生出一个实例。如果模板可以产生一个具有更好匹配的函数， 那么将选择模板：
int Add(int t1, int t2)//返回值类型是泛型
{
return t1 + t2;
}
template <typename T>
T Add(const T& t1, const T& t2)//返回值类型是泛型
{
return t1 + t2;
}
int main()
{
Add(1, 2);
Add(1, 2.0);
return 0;
}F10-调试-窗口-反汇编：
发现Add(1,2)与非函数模板匹配，直接调用现成的Add函数，省去了对模板参数类型T的推演，编译器不需要进行模板函数实例化：
发现Add(1,2.0)与非模板函数不匹配，编译器只能根据实参生成更加匹配的Add函数：
三、类模板
1.类模板定义
当有多个类时，其功能相同，仅仅数据类型不同，就可以使用类模板：
template <class T1, class T2, ……, class Tn>
class 类模板名
{
//类内成员定义
};例如对于链表，以下代码只能插入整型结点，因为限定了VDataType的类型为int型：
#include<iostream>
#include<assert.h>
using namespace std;
typedef int VDataType;//限定了VDataType的类型只能为int型
class vector
{
public:
//构造函数
vector()
:_a(nullptr)
, _size(0)
, _capacity(0)
{}
//析构函数
~vector()
{
delete[] _a;
_a = nullptr;
_size = _capacity = 0;
}
//读写第pos个位置的元素
int& operator[](size_t pos)
{
assert(pos < _size);
return _a[pos];
}
//求数组大小
size_t size()
{
return _size;
}
//插入节点
void push_back(const int& x)
{
if (_size == _capacity)
{
int newCapacty = _capacity == 0 ? 4 : _capacity * 2;
int* tmp = new int[newCapacty];
if (_a)
{
memcpy(tmp, _a, sizeof(int) * _size);
delete[] _a;
}
_a = tmp;
_capacity = newCapacty;
}
_a[_size] = x;
++_size;
}
private:
VDataType* _a;
int _size;
int _capacity;
};但是现在如果想借助这一份代码，让链表v1存int型数据，让另一个链表v2存double型数据，该怎样实现呢？使用类模板：
#include<iostream>
#include<assert.h>
using namespace std;
template<class T>//类模板定义
class vector
{
public:
//构造函数
vector()
:_a(nullptr)
, _size(0)
, _capacity(0)
{}
//析构函数
~vector()
{
delete[] _a;
_a = nullptr;
_size = _capacity = 0;
}
//读写第pos个位置的元素
T& operator[](size_t pos)
{
assert(pos < _size);
return _a[pos];
}
//求数组大小
size_t size()
{
return _size;
}
//插入节点
void push_back(const T& x) //指定参数类型
{
if (_size == _capacity)
{
int newCapacty = _capacity == 0 ? 4 : _capacity * 2;
T* tmp = new T[newCapacty];//指定tmp类型，以便后面赋值给_a
if (_a)
{
memcpy(tmp, _a, sizeof(int) * _size);
delete[] _a;
}
_a = tmp;
_capacity = newCapacty;
}
_a[_size] = x;
++_size;
}
private:
T* _a; //指定成员变量类型
int _size;
int _capacity;
};vector不是具体的类，是编译器根据被实例化的类型生成具体类的模具。以上仅仅只是类模板的显式指定，如何向v1中插入int型数据，向v2中插入double型数据呢？
int main()
{
delia::vector<int> v1; //v1存放int型数据，生成T是int型的vector
v1.push_back(1);
v1.push_back(2);
//v1[i]等价于v1.operator()[i]
for (size_t i = 0; i < v1.size(); i++)
{
cout << v1[i] << " ";
}
cout << endl;
for (size_t i = 0; i < v1.size(); i++)
{
v1[i] *= 2;
cout << v1[i] << " ";
}
cout << endl;
delia::vector<double> v2; //v2存放double型数据，生成T是double型的vector
v2.push_back(1.1);
v2.push_back(2.2);
return 0;
}由于库里面有vector头文件，假如在库里包含了#include<vector>的头文件，编译器就不知道到底要调库里的vector还是我们自己写的vector。把库里的vector放在std命名空间中，把自己写的vector放在另一个命名空间中，就能把两个vector隔离开了：
#include<iostream>
#include<vector>
#include<assert.h>
using namespace std;
namespace delia
{
template<class T>//类模板定义
class vector
{
public:
//构造函数
vector()
:_a(nullptr)
, _size(0)
, _capacity(0)
{}
//析构函数
~vector()
{
delete[] _a;
_a = nullptr;
_size = _capacity = 0;
}
//读写第pos个位置的元素
T& operator[](size_t pos)
{
assert(pos < _size);
return _a[pos];
}
//求数组大小
size_t size()
{
return _size;
}
//插入节点
void push_back(const T& x) //指定参数类型
{
if (_size == _capacity)
{
int newCapacty = _capacity == 0 ? 4 : _capacity * 2;
T* tmp = new T[newCapacty];//指定tmp类型，以便后面赋值给_a
if (_a)
{
memcpy(tmp, _a, sizeof(int) * _size);
delete[] _a;
}
_a = tmp;
_capacity = newCapacty;
}
_a[_size] = x;
++_size;
}
private:
T* _a; //指定成员变量类型
int _size;
int _capacity;
};
}现在可以打印某个位置的数据了：
int main()
{
delia::vector<int> v1; //v1存放int型数据，生成T是int型的vector
v1.push_back(1);
v1.push_back(2);
//v1[i]等价于v1.operator()[i]
for (size_t i = 0; i < v1.size(); i++)
{
cout << v1[i] << " ";
}
cout << endl;
for (size_t i = 0; i < v1.size(); i++)
{
v1[i] *= 2;
cout << v1[i] << " ";
}
cout << endl;
delia::vector<double> v2; //v2存放double型数据，生成T是double型的vector
v2.push_back(1.1);
v2.push_back(2.2);
return 0;
}
如果函数声明和定义分开，比如在类里面声明函数，但是在类外面定义函数，需要在函数定义的位置再定义一个模板参数，让编译器知道T是一个模板类型，否则编译器识别不了T是从哪里来的，是什么：
#include<iostream>
#include<vector>
#include<assert.h>
using namespace std;
namespace delia
{
template<class T>//类模板定义
class vector
{
public:
//构造函数
vector()
:_a(nullptr)
, _size(0)
, _capacity(0)
{}
//析构函数
~vector()
{
delete[] _a;
_a = nullptr;
_size = _capacity = 0;
}
//类里面，读写第pos个位置的元素：函数声明
T& operator[](size_t pos);
//求数组大小
size_t size()
{
return _size;
}
//插入节点
void push_back(const T& x) //指定参数类型
{
if (_size == _capacity)
{
int newCapacty = _capacity == 0 ? 4 : _capacity * 2;
T* tmp = new T[newCapacty];
if (_a)
{
memcpy(tmp, _a, sizeof(int) * _size);
delete[] _a;
}
_a = tmp;
_capacity = newCapacty;
}
_a[_size] = x;
++_size;
}
private:
T* _a; //指定成员变量类型
int _size;
int _capacity;
};
//类外面，读写第pos个位置的元素:函数定义
template<class T>//用模板类型指定了具体类型
T& vector<T>:: operator[](size_t pos)
{
assert(pos < _size);
return _a[pos];
}
}2.类模板的实例化
类模板实例化与函数模板实例化不同，类模板实例化需要在类模板名字后跟<>，然后将实例化的类型放在<> 中即可，类模板名字不是真正的类，而实例化的结果才是真正的类。
delia::vector<int> v1; //vector是类模板名字，vector<int>才是类型模板进阶
一、模板参数
模板参数分为类型形参和非类型形参。
1.类型形参
出现在模板参数列表中，跟在class或typename之后的参数类型名称。如下代码中跟在class后的T就是类型形参：
template<class T>
class Array
{
public:
private:
T _a[N];
};2.非类型形参
用一个常量作为类或函数模板的一个参数，在类或函数模板中把这个参数当成常量来用，如下代码中的N就是非类型形参，它是模板的另外一个参数：
//template<class T, size_t N> // 给定常量
template<class T, size_t N = 20> // 还可以是缺省参数
class Array
{
public:
private:
T _a[N];
};注意：
（1）非类型模板参数 -- 整形常量，不可被修改, bool类型也属于整形
template<double N>
//N是非类型模板参数，编译报错，类型非法，不允许double型二、模板的特化
// 函数模板 -- 参数匹配
template<class T>
bool Less(T left, T right)
{
return left < right;
}
int main()
{
cout << Less(1, 2) << endl; // 可以比较，结果正确
Date d1(2022, 7, 7);
Date d2(2022, 7, 8);
cout << Less(d1, d2) << endl; // 可以比较，结果正确
Date* p1 = &d1;
Date* p2 = &d2;
cout << Less(p1, p2) << endl; // 可以比较，结果错误
return 0;
}1.函数模板特化
特化步骤：
1. 必须要先有一个基础的函数模板
2. 关键字template后面接一对空的尖括号<>
3. 函数名后跟一对尖括号，尖括号中指定需要特化的类型
4. 函数形参表: 必须要和模板函数的基础参数类型完全相同，如果不同编译器可能会报一些奇怪的错误。
// 对Less函数模板进行特化
// 全特化
template<>
bool Less<Date*>(Date* left, Date* right)
{
return *left < *right;
}
// 调用特化之后的版本，而不走模板生成了
cout << Less(p1, p2) << endl; bool Less(Date* left, Date* right)
{
return *left < *right;
}2.类模板特化
类模板在没有写类特化之前，调的都是原模板的，如下代码，定义了类模板，日期类为例：
// 原模板
template<class T>
struct Less
{
bool operator()(const T& t1, const T& t2) const
{
return t1 < t2;
}
};（1）全特化
全特化是把模板参数列表中的所有参数都确定化。
把T1指定成Date*
// 全特化
template<>
struct Less<Date*>
{
bool operator()(const Date* t1, const Date* t2) const
{
return *t1 < *t2;
}
};（2）偏特化
偏特化是任何针对模板参数进一步进行条件限制的特化版本。偏特化分为两种表现方式：
①部分特化：把模板参数类表中的一部分参数特化
// 将第二个参数特化为int
template <class T1>
class Data<T1, int>
{
public:
Data() { cout << "Data<T1, int>" << endl; }
private:
T1 _d1;
int _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 Test_Class()
{
Data<int, int> d1;
Data<int, double> d2;
Data<int, char> d3;
Data<char*, char*> d4;//会调用两个参数偏特化为指针类型的偏特化
Data<double&, double&> d5(2.1, 3.2);//会调用两个参数偏特化为引用类型的偏特化
}最后，编译器匹配参数时，会自动匹配最匹配的那个，编译器实例化之后就没有模板了，实例化之后就会把T1&替换成double&，把T2&替换成double&，就变成了普通类。
假如参数类型一个是指针，一个是引用呢？将一个参指定为指针类型，另外一个参数指定为引用类型
//还可以混着玩
template <typename T1, typename T2>
class Data <T1&, T2*>
{
public:
Data(const T1& d1 = T1())
{
cout << "Data<T1&, T2*>" << endl;
}
private:
const T1& _d1;
T2 _d2;
};三、模板分离编译
分离式编译：一个程序（项目）由若干个源文件共同实现，而每个源文件单独编译生成目标文件，将所有目标文件连接起来形成单一的可执行文件的过程称为分离编译模式。
1.模板支持分离编译吗
对于分离式编译的模板:
template.h
template<class T>
T Add(const T& left, const T& right);template.cpp
#include "template.h"
template<class T>
T Add(const T& left, const T& right)
{
return left + right;
}template-main.cpp
#include "template.h"
int main()
{
Add(1, 2);
Add(1.0, 2.0);
return 0;
}上述代码运会报错：
2.为什么模板不支持分离编译
程序要运行，需要经过预处理、编译、汇编、链接4个阶段
（1）预处理
包含头文件、宏替换、、条件编译、删除注释
（2）编译
语法分析、词法分析、语义分析，符号汇总
（3）汇编
汇编代码转换成机器指令 、生成符号表
（4）链接
链接目标文件和连接库、合并符号表、重定位
预处理阶段，#include "template.h"包含头文件，认为会有Add函数的定义。编译时在符号表里填上符号和地址，生成符号表，编译阶段只有函数声明，没有函数定义，如果有人调用了这个符号，就能通过符号表找到这个符号对应的地址。但是函数模板不会生成对应符号。汇编时把符号转换成二进制，这样，机器就可以识别了。链接时会去找函数地址进行合并重定位。
虽然编译时，想生成函数模板对应的符号，但是此时并不知道T是什么，由于在链接之前，各个文件不知道对方的存在，所以template-main.cpp无法告诉template.cpp T具体是什么，template.cpp中无法对T进行实例化，会寄希望于最后一步链接，所以不会生成对应符号。即，定义的地方(template.cpp)不实例化，而实例化的地方(template-main.cpp)没有定义，只有声明。没有实例化T，生成不了函数模板的符号。
3.如何编译模板文件
如何解决函数模板不能生成对应符号，导致程序运行不了的问题呢？有两种方法
（1）显式指定实例化
模板定义时直接指定T的类型，即增加模板的特化，将template.cpp改为：
#include "template.h"
template<class T>
T Add(const T& left, const T& right)
{
return left + right;
}
//增加int类型的模板特化
template<>
int Add<int>(const int& left, const int& right)
{
return left + right;
}
//增加double类型的模板特化
template<>
double Add<double>(const double& left, const double& right)
{
return left + right;
}（2）将声明和定义放到一个文件中（推荐）
将template.h和template.cpp合并成一个文件，这个文件名可以是template.h，也可以是template.cpp，此时template就只剩下一个文件了。
template.h
template<class T>
T Add(const T& left, const T& right);
template<class T>
T Add(const T& left, const T& right)
{
return left + right;
}template.main不变
#include "template.h"
int main()
{
Add(1, 2);
Add(1.0, 2.0);
return 0;
}大功告成，编译成功！
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
