泛型编程
如果要交换两个int类型的数据是这样的：
#include <iostream> using namespace std; void swap(int& x,int& y) { int z = x; x = y; y = z; } int main() { int x = 10; int y = 20; swap(x, y); cout << x << ' ' << y << endl; return 0; }
那么，如果你想交换两个其他类型的就需要写一个重载函数，这样是非常麻烦的。
这时C++就有了模板。
函数模板
概念与格式
函数模板，也是一种函数。
模板格式：template <参数列表>
函数（模板的下一行必须是函数的定义，不能分开）
template是关键字，参数中的typename和class也是关键字
#include <iostream> using namespace std; template <class T> void Swap(T& x,T& y)//这里class也可以换成typename，其他的不行 { T z = x; x = y; y = z; } int main() { int x = 10; int y = 20; Swap(x, y); double a = 1.0; double b = 2.0; Swap(a, b); char i = 'a'; char j = 'c'; Swap(i, j); cout << x << ' ' << y << endl; cout << a << ' ' << b << endl; cout << i << ' ' << j << endl; return 0; }
这里T是无类型，谁调用就去推演谁。
原理：
模板就像一个摸具一样，本身是一个摸具，不是成品，要添加材料然后进行生产加工才是，这里就是添加参数和代码，让编译器去帮助你创建你需要的重复性很高的函数。
在编译器编译阶段，编译器会将输入的对应参数进行推演然后生成该类型的函数。
创建对应的函数叫做实例化，就像类与对象中创建的对象一样。
模板的实例化
实例化分为两种：
- **隐式实例化：**让编译器根据实参推演模板参数的实际类型
如果遇到这种情况，模板只有一个参数，但是传参的时候有连个不同的类型怎么办？
#include <iostream> using namespace std; template <class T> void Swap(T& x, T& y) { T z = x; x = y; y = z; } int main() { int x = 1; double y = 2.0; Swap(x, y); return 0; }
这里编译器就不知道应该转换成什么类型了，导致报错。
有三种方法：
一是加一个参数，二是对于某一个不同类型的参数进行强制类型的转换。
#include <iostream> using namespace std; template <class T> void Swap(T& x, const T& y)//因为y是强制类型转换过来的，这里要加const { cout << x << ' ' << y << endl;//既然有一个加了const，那么这里肯定不能交换数据了 } int main() { int x = 1; double y = 2.0; Swap(x, (int)y);//这里调用模板函数编译器就会推演让T变成int类型，然后用模板实例化 return 0; }
三：显式实例化：在函数名后的<>中指定模板参数的实际类型
#include <iostream> using namespace std; template <class T> void Swap(T& x, const T& y)//因为y需要隐式类型转换，需要加const { cout << x << ' ' << y << endl; } int main() { int x = 1; double y = 2.0; Swap<int>(x, y);//这里是我们将模板参数中的T变成int类型，不需要编译器推演直接进行实例化 return 0; }
如果类型不匹配，编译器会尝试进行隐式类型转换，如果无法转换成功编译器将会报错。
模板参数的匹配
有没有想过一个问题，如果有一个模板函数实例化出来的函数和已经存在的函数是一样的怎么办？
格式：template<参数>
类（这里和函数一样，不能和模板分开）
#include <iostream> using namespace std; int Add(int& x, int& y) { cout << "本地" << endl; return x + y; } template <class N> N Add(N& x,N& y) { cout << "模板" << endl; return x + y; } int main() { int x = 10; int y = 20; Add(x, y);//这里肯定是先调用本地有的Add函数，因为模板函数还需要自己创建一个函数 Add<int>(x, y);//这里用显式实例化等于调用模板函数 double a = 1.0; double b = 2.0; Add(a, b);//这里会调用模板函数，因为模板函数更加合适 return 0; }
类模板与模板类
之前写的栈里面进行压栈然后存入数据，但是只能存入一个类型的数据，那么定义一个类模板就可以解决问题了。
#include <iostream> using namespace std; template <class N> class Stack { public: Stack(int x = 4) :_capacity(0) ,_siz(0) { _a = (N*)malloc(x * sizeof(N)); if (_a == nullptr) { perror("malloc fail");; exit(-1); } _capacity = x; _siz = 0; } ~Stack() { free(_a); _a = nullptr; _capacity = _siz = 0; } void Push(const N& x)//这里加引用更好，如果N是一个自定义类型传参就需要拷贝构造 { _a[_siz] = x; _siz++; } private: N* _a; int _capacity; int _siz; }; int main() { Stack <int>s1;//这里必须是显示实例化 s1.Push(1); s1.Push(2); s1.Push(3); Stack<double>s2; s2.Push(4.5); s2.Push(5.5); s2.Push(6.5); return 0; }
那么在类模板实例化（也就是模板类）的过程中是不可能隐式实例化的，因为在创建一个模板类时，最先调用的时构造函数，但是构造函数不一定就要传参或者是模板参数类型，所以编译器无法推演，你直接告诉编译器把N都变成int类型就好了。
注意：这两个模板类不是同一个类型。
因为里面的成员大小都不同了。
关于数组越界访问这档事
之前在用数组的时候，编译器对于越界访问的检查是不同的，VS编译器是抽查，到达某个位置之后就不查了，有些地方你甚至可以修改，这是个令人头疼的问题，之前还学过一个东西是断言，如果能把断言利用在检查数组是否越界会不会更好？
#include <iostream> #include <assert.h> #define N 10 using namespace std; template <class T> class Arr { public: inline T& operator[](int i)//改成内联函数，影响效率的问题可以忽略不计 { assert(i >= 0 && i < N);//越界检查 return _a[i]; } private: T _a[N]; }; int main() { Arr<int>arr; int i = 0; for (i = 0; i < N; i++) { arr[i] = 0;//这里等于arr.operator[](i)，返回的是_a[i] } return 0; }
这样就不担心数组越界访问了。
经典问题——类模板不能分离编译
注意：模板是不支持分离编译的。
那么，我们平时讲究的是声明和定义进行分离，但是模板是不允许分离的：
//test.h #include <iostream> using namespace std; template <class N> class Stack { public: Stack(int x = 4); ~Stack(); void Push(const N& x); private: N* _a; int _capacity; int _siz; }; //test.cpp #include "test.h" template<class N>//这里要定义要定义一个模板参数，不然不知道N是什么，等于再次声明 Stack<N>::Stack(int x) { _a = (N*)malloc(x * sizeof(N)); if (_a == nullptr) { perror("malloc fail"); exit(-1); } _capacity = x; _siz = 0; } template<class N> Stack<N>::~Stack() { free(_a); _a = nullptr; _capacity = _siz = 0; } template<class N> void Stack<N>::Push(const N& x) { _a[_siz] = x; _siz++; } //源.cpp #include "test.h" int main() { Stack <int>s1; s1.Push(1); s1.Push(2); s1.Push(3); }
这里分成了三个文件，在test.cpp要注意，分离需要说明成员函数属于哪个类型，而不是类名，用类模板说明类型就需要在类名后面加 <类型>，类名+<类型>才是我们需要的类型。
因为我们定义类模板实例化的时候就是这个格式，如果不加<类型>传过来的是Stack或者是Stack，类型都不匹配。
运行的时候发现报错了，这里是链接错误，说明没有语法性的错误，只是找不到函数的定义。
原因是因为：
在预处理的时候展开头文件，那么主函数的文件只有头文件的内容，没有两一个源文件的内容，编译的时候要去调用函数，因为头文件里有函数的声明，所以编译通过，链接的时候是通过符号表去找地址，但是编译期间出现了错误，说明找不到函数的地址。（函数定义的地方才是放入符号表的地址）
我们在创建实例化时，能实例化的只有声明，因为模板是一个蓝图，没有定义只有声明就无法实例化，另一个源文件在有函数定义的文件里又没有实例化，所以就无法放入符号表中，没办法找到。
有两种方法解决这个问题；
- 显式实例化：
在定义的地方没有进行实例化，那么进行一次实例化不就可以了吗，然后放进符号表里就可以找到了。
//test.cpp #include "test.h" template<class N> Stack<N>::Stack(int x) { _a = (N*)malloc(x * sizeof(N)); if (_a == nullptr) { perror("malloc fail"); exit(-1); } _capacity = x; _siz = 0; } template<class N> Stack<N>::~Stack() { free(_a); _a = nullptr; _capacity = _siz = 0; } template<class N> void Stack<N>::Push(const N& x) { _a[_siz] = x; _siz++; } template class Stack<int>;
但是这种有一个很致命的缺陷，如果你想存入double类型的数据，但是刚才之创建了一个int类型的函数定义，那么符号表中没有double类的函数地址，也会报错，这时就需要你再次去定义一个double类型的，很麻烦。
2. 不分离（在同一文件内）
当然，只有不分离是更好的，这里指在同一个文件里。
这样就不需要链接去找了，因为是直接展开的，不仅仅有声明，还有定义，这样你在主函数的地方实例化就不需要在外部找定义了，在同文件中被实例化之后直接就放入了符号表内。
//test.h #include <iostream> using namespace std; template <class N> class Stack { public: Stack(int x = 4); ~Stack(); void Push(const N& x); private: N* _a; int _capacity; int _siz; }; template<class N> Stack<N>::Stack(int x) { _a = (N*)malloc(x * sizeof(N)); if (_a == nullptr) { perror("malloc fail"); exit(-1); } _capacity = x; _siz = 0; } template<class N> Stack<N>::~Stack() { free(_a); _a = nullptr; _capacity = _siz = 0; } template<class N> void Stack<N>::Push(const N& x) { _a[_siz] = x; _siz++; } //源.cpp #include "test.h" int main() { Stack <int>s1; s1.Push(1); s1.Push(2); s1.Push(3); Stack<double>s2; s2.Push(4.5); s2.Push(5.5); s2.Push(6.5); return 0; }
编译就通过了。
