泛型编程
void Swap(int& left, int& right) { int temp = left; left = right; right = temp; } void Swap(double& left, double& right) { double temp = left; left = right; right = temp; } void Swap(char& left, char& right) { char temp = left; left = right; right = temp; }
交换函数，对于多种类型，需要写多个交换函数
使用函数重载虽然可以实现，但是有一下几个不好的地方：
1. 重载的函数仅仅是类型不同，代码复用率比较低，只要有新类型出现时，就需要用户自己增加对应的函
数
2. 代码的可维护性比较低，一个出错可能所有的重载均出错
C++中，我们可以用“模板”只需要写一个函数就可以针对多种类型进行使用，这种方法就叫泛型编程。
泛型编程：编写与类型无关的通用代码，是代码复用的一种手段。模板是泛型编程的基础
函数模板
函数模板概念
函数模板代表了一个函数家族，该函数模板与类型无关，在使用时被参数化，根据实参类型产生函数的特定类型版本。
函数模板格式
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代替class)，typename后面<>中类型名字T是随便取的，一般是大写字母或单词首字母大写
T代表是一个模板类型（虚拟类型）
函数模板是一个蓝图，它本身并不是函数，是编译器用使用方式产生特定具体类型函数的模具。所以其实模板就是将本来应该我们做的重复的事情交给了编译器
观察 上面函数地址，可发现调用的不是同一个函数
在使用C++时，不需要字节写swap函数，std库里面有swap函数（四个字母都是小写），可直接拿来使用
C语言中，之前写交换用异或，但这种方式只能针对整形，所以建议用swap
函数模板的实例化
第二个Add会报错
如果不是模板形式，则不会报错，但会有警告，发生了隐式类型转换
我们可以比较出，模板不能发生隐式类型转换
这是因为在推演实例化的时候报错，根据第一个参数，推演出T时int类型，但第二个参数T又是double类型，所以会报错
解决方法如下：
方法1 传参之前前置类型转换，这种方法也叫编译器自动推演，隐式实例化
方法2 显示实例化
在函数名和参数中间加<>
方法一 是在传参之前就把自己的类型给强制转换了，方法二是把指定T为<>中的类型
这种情况下必须用显示实例化，不然会报错
编译器没办法自动推演出自定义类型，所以要加上显示实例化
显示实例化也可以这样使用
template<typename T1,typename T2> T1 Add(const T1& left, const T2& right) { return left + right; } int main() { Add(10, 10.000); return 0; }
模板参数的匹配原则
1. 一个非模板函数可以和一个同名的函数模板同时存在，而且该函数模板还可以被实例化为这个非模板函数
第一个Add调用了，Add函数，第二个Add，调用了模板
当给第一个换了实参以后，第一个函数会调用模板，这是因为编译器会对参数有一个匹配机制
实际中不建议写这种代码
类模板
类模板定义格式
template<class T1, class T2, ..., class Tn> class 类模板名 { // 类内成员定义 };
对于之前我们写的栈类型
typedef char STDataType; class Stack { private: STDataType* _a; int top; int capacity; }; int main() { Stack st1; return 0; }
如果创建俩个变量st1要求数组是char类型，st2要求是int类型，上面写的这种栈实现起来比较麻烦
我们可以用类模板来解决上面这个问题
template <typename T> class Stack { public: Stack(size_t capacity=4) :_a(nullptr), _capacity(0), _top(0) { if (capacity > 0) { _a = new T[capacity]; _capacity = capacity; _top = 0; } } private: T* _a; int _top; int _capacity; }; int main() { //类模板都是实例化 Stack<int> st1(100);//默认构造时传的100 Stack<char> st2; return 0; }
类模板都是实例化，虽然它们用了一个类模板，但是它们是俩个类型
template<typename T> class Stack { public: Stack(size_t capacity = 4) :_a(nullptr) , _top(0) , _capacity(0) { if (capacity > 0) { _a = new T[capacity]; _capacity = capacity; _top = 0; } } Stack(size_t capacity = 0) { if (capacity > 0) { _a = new T[capacity]; _capacity = capacity; _top = 0; } } ~Stack() { delete[] _a; _a = nullptr; _capacity = _top = 0; } Push(const T& x) { if (_top == _capacity) { size_t newCapacity = _capacity == 0 ? 4 : _capacity * 2; T* tmp = new T[newCapacity]; if (_a) { memcpy(tmp, _a, sizeof(T) * _top); delete[] _a; } _a = tmp; _capacity = newCapacity; } _a[_top] = x; ++_top; } void Pop() { assert(_top > 0); --_top; } bool Empty() { return _top == 0; } const T& Top() { assert(_top > 0); return _a[_top - 1]; } private: T* _a = nullptr; size_t _top = 0; size_t _capacity = 0; };
模板不支持一个在.h生命在.cpp定义
但支持在同一个.cpp文件里面声明和定义分离
有的地方会把模板写道.hpp文件中
模板也能给缺省参数，只不过给的是类型
这样写记得加上<>,不加就会报错
习题
习题1 下面有关C++中为什么用模板类的原因，描述错误的是? ( ）
A.可用来创建动态增长和减小的数据结构
B.它是类型无关的，因此具有很高的可复用性
C.它运行时检查数据类型，保证了类型安全
D.它是平台无关的，可移植性
选C
A.模板可以具有非类型参数，用于指定大小，可以根据指定的大小创建动态结构
B.模板最重要的一点就是类型无关，提高了代码复用性
C.模板运行时不检查数据类型，也不保证类型安全，相当于类型的宏替换，故错误
D.只要支持模板语法，模板的代码就是可移植的
习题2 下列关于模板的说法正确的是（ ）
A.模板的实参在任何时候都可以省略
B.类模板与模板类所指的是同一概念
C.类模板的参数必须是虚拟类型的
D.类模板中的成员函数全是模板函数
选D
A.不一定，参数类型不同时有时需要显示指定类型参数
B.类模板是一个类家族，模板类是通过类模板实例化的具体类
C.C++中类模板的声明格式为template＜模板形参表声明＞＜类声明＞，并且类模板的成员函数都是模板函数
D.正确，定义时都必须通过完整的模板语法进行定义
习题3下列描述错误的是（ ）
A.编写与类型无关的通用代码，是代码复用的一种手段。模板是泛型编程的基础
B.函数模板是一个蓝图，它本身并不是函数，是编译器用使用方式产生特定具体类型函数的模具
C.模板分为函数模板和类模板
D. 模板类跟普通类以一样的，编译器对它的处理时一样的
选D
A.模板是代码复用的重要手段
B.函数模板不是一个具体函数，而是一个函数家族
C.目前涉及到的模板就两类，函数模板与类模板
D.模板类是一个家族，编译器的处理会分别进行两次编译，其处理过程跟普通类不一样
