一、泛型编程思想

• 首先我们来看一下下面这三个函数，如果学习过了 C++函数重载 和 C++引用 的话，就可以知道下面这三个函数是可以共存的，而且传值会很方便

• 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;
  }
  

但是真的很方便吗？这里只有三种类型的数据需要交换，若是我们需要增加交换的数据呢？再CV然后写一个函数吗？

 这肯定是不现实的，所以很明显函数重载虽然可以实现，但是有一下几个不好的地方：

1. 重载的函数仅仅是类型不同，代码复用率比较低，只要有新类型出现时，就需要用户自己增加对应的函数
2. 代码的可维护性比较低，一个出错可能所有的重载均出错

 那是否能做到这么一点，告诉编译器一个模子，让编译器根据不同的类型利用该模子来生成代码
这样，我们先通过一个案例来做引入

• 才高八斗的魏武帝之子【曹植】曾经写过一首《洛神赋》，被后人誉为“千古第一绝世神仙诗”，因此在那个时候被很多文人所抄录、传唱，其共1089个字，想要一字不落地抄录下来还是需要时间，那古代还有一些更长的诗赋，例如：《离骚》，足足有2500多字，若也是一个一个地抄录下来的话，那会变得极为麻烦

• 于是呢古人又发明了一种东西叫做【活字印刷术】，有了此技术之后，人们不再需要每次去手抄一些诗赋书籍，只需要作一份模版字体，然后在其上刷上水，刷上墨，然后拿纸这么一印，就可以得到一份工整的印刷体了

  💬 所以，总结上面的这么一个技术，C++的祖师爷呢就想到了【模版】这个东西，告诉编译器一个模子，然后其余的工作交给它来完成，根据不同的需求生成不同的代码

这就是👉泛型编程：编写与类型无关的通用代码，是代码复用的一种手段。模板是泛型编程的基础

二、函数模版

知晓了模版的基本概念后，首先我们要来看的就是【函数模版】

1、函数模板概念

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

通过函数模板，可以编写一种通用的函数定义，使其能够适用于多种数据类型，从而提高代码的复用性和灵活性。

2、函数模板格式

• 然后正式来声明一个函数模版，这里我们要学一个新的关键字叫template，接下去加一个<>尖括号，内部就是模版的参数了，可以使用typename或者class来进行类型的声明（不可以用struct），若是只有一个类型的话我们一般会叫做【T】，不过这个没有强制要求

template<typename T1, typename T2,......,typename Tn>

• 接下去就可以使用上面所声明的模版参数了，即上面的这个【T】，它和我们普通的函数参数可不一样，后者是定义的是对象，而前者定义的是类型

  返回值类型 函数名(参数列表){}
  

  马上，我们就来为上面的swap()函数写一个通用的函数模版把

  template<typename T>
  void Swap(T& left, T& right)
  {
  	T temp = left;
  	left = right;
  	right = temp;
  }
  

• 然后来用一用这个函数模版，分别传入不同数据类型的参数，通过结果的观察可以发现这个函数模版可以根据不同的类型去做一个自动推导，继而去起到一个交换的功能

• 我们可以通过调试来进一步观察，发现无论是对于【整型】还是【浮点型】，都会去走这个Swap()函数，函数模版都可以进行自动的识别

 那我现在想问一个问题，请问它们调用的真的是同一个函数吗？

•  相信很多同学都说是的，上面不是演示过了吗？但是看完下面这一小节你就不会这么说了👇

 3、函数模板的原理

接下去我们来说说这个函数模版的原理，带你理清编译器内部究竟做了什么事情

• 对于函数模板而言其实是一个【蓝图】，它本身并不是函数，是编译器用使用方式产生特定具体类型函数的模具。所以其实模板就是将本来应该我们做的重复的事情交给了编译器，让我们来看看编译器做了什么
  

• 可以发现，在进行汇编代码查看的时候，被调用的函数模版生成了两个不同的函数，它们有着不同的函数地址，因此可以回答上一小节所提出的问题了，两次所调用的函数是不一样的，是根据函数模版所生成的

还是不太懂的老铁可以看看下面这张图，就能明白了

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

 💬 那我现在还想问，如果我使用的是两个日期类Date的对象呢，能不能对它们进行交换

•  答案是可以的，int、double、char这些都是内置类型，Date呢是自定义类型，很明显它们都是类型，我们所定义的模版参数也是类型，那为何不可去做一个接受呢？从运行结果可以来看，确实是可以发现它们也发生了一个交换

💬 那如果是指针呢？也会去调用吗？

•  如何你学的扎实得话，立马就能反应过来了，对于指针而言也是内置类型，那既然是类型的话为何不能调用呢？

既然谈到了这个【Swap】交换函数，我们就顺便来说说库里的这个【swap】

• 仔细观察下图可以发现我将Swap前面大写S改成了小写s，它就是std标准库的里面的一个函数，也包含在STL的基本算法中

• 进到文档里面进行查看我们可以发现这个函数确实已经实现了【函数模版】，因此可以接收任何类型的数据，所以在学习了函数模版后我们就不需要自己再去写swap()函数了，直接用库里的即可

4、函数模板的实例化

上面我们所定义的都是单个模版参数，那多个模版参数是否可以定义呢？

• 这个当然是可以的，我们立马来试试看吧

  template<typename T1, typename T2>
  T1 Func(const T1& x, const T2& y)
  {
  	cout << x << " " << y << endl;
  }
  

• 通过运行可以发现，是完全可以做到的，去定义多个模版参数，这个特性本文就不做距离了，等我们学习了一些STL之后再【模版进阶】一文中详解

然后我们来讲讲【函数模板的实例化】

👉 用不同类型的参数使用函数模板时，称为函数模板的实例化。模板参数实例化分为：隐式实例化和显式实例化

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

• 知道模版可以定义多个参数之后，其返回值也可以是模版参数

  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;
  	// 根据实参传递的类型，推演T的类型
  	cout << Add(a1, a2) << endl;
  	cout << Add(d1, d2) << endl;
  }
  

  

• 但是呢像下面这种就不可以了，因为a1是【int】类型，d1是【double】类型，在编译期间，当编译器看到该实例化时，需要推演其实参类型 通过实参a1将T推演为int类型，通过实参d1将T推演为double类型，但模板参数列表中只有一个T， 编译器无法确定此处到底该将T确定为int 或者 double类型而报错。此时在函数调用完后进行返回时，编译器也识别不出是哪个类型了，它们两个就像在打架一样，很难一绝高下

  cout << Add(a1, d2) << endl
  

  

  好比你做错事了，你爸爸让你罚站，不让你吃饭，此时呢你妈妈回来了，让你赶紧过来吃饭，那此时你该听谁的呢？

• 那此时呢就需要爸爸妈妈回房间商量一下了，到底是以谁说的话为主呢

那当他们商量好了之后，就会有下面这两种情况

• 这一种改法便是听爸爸的，后者d1强转为int类型然后再传递进去，此时就不会出现类型冲突的问题了

  cout << Add(a1, (int)d2) << endl;
  

• 这种改法便是听妈妈的，前者a1强转为double类型然后再传递进去，也不会出现类型冲突的问题

  cout << Add((double)a1, d2) << endl;
  

1. 显式实例化：在函数名后的<>中指定模板参数的实际类型

• 除了上面这种手动强转的措施，还有一种办法就是我们自己进行【显式实例化】，如何你还有印象的话，可以翻上看看汇编，其实编译器在底层就是转换为了这种形式

// 显式实例化，用指定类型实例化
cout << Add<int>(a1, d2) << endl;
cout << Add<double>(a1, d2) << endl;

虽然上面我们介绍了两种处理方式，但是对于某些场景来说，却只能进行【显式实例化】

• 例如我在下面写了一个函数模版，形参部分并不是模版参数，而是普通的自定义类型，之后返回值才是，那此时我们就无法通过传参来指定这个【T】的类型，只能有外部在调用这个模版的时候显示指定

  template<class T>
  T* Alloc(int n)
  {
  	return new T[n];
  }
  

• 例如下面的这些，我们想开什么数据类型的空间，只需要显示指定类型即可

  // 有些函数无法自动推，只能显示实例化
  double* p1 = Alloc<double>(10);
  float* p1 = Alloc<float>(20);
  int* p2 = Alloc<int>(30);
  

  5、模板参数的匹配原则

① 一个非模板函数可以和一个同名的函数模板同时存在，而且该函数模板还可以被实例化为这个非模板函数

• 可以看到，我在下面写了一个专门处理int的加法函数，为普通的函数，又写了一个函数模版，它们是可以进行共存的，在进行普通传参的时候，就会去调用这个普通的Add函数；若是显式指明了类型的话，就会去调用这个函数模版让编译器生成对应的函数

  // 专门处理int的加法函数
  int Add(int left, int right)
  {
  	return left + right;
  }
  
  // 通用加法函数
  template<class T>
  T Add(T left, T right)
  {
  	return left + right;
  }
  
  int main(void)
  {
  	Add(1, 2);
  	Add<int>(1, 2);
  	return 0;
  }
  

  

  ② 对于非模板函数和同名函数模板，如果其他条件都相同，在调动时会优先调用非模板函数而不会从该模板产生出一个实例。如果模板可以产生一个具有更好匹配的函数， 那么将选择模板

• 也是和上面类似的代码，不过对于函数模版这一块我使用到了两个模版参数，就是为了匹配多种数据类型

// 专门处理int的加法函数
int Add(int left, int right)
{
	return left + right;
}

// 通用加法函数
template<class T1, class T2>
T1 Add(T1 left, T2 right)
{
	return left + right;
}

int main(void)
{
	Add(1, 2);
	Add(1, 2.2);
	return 0;
}

• 观察调试结果我们可以发现Add(1, 2)优先去调了普通的加法函数，因为传递进去的是两个【int】类型的参数，完全吻合；但是呢对于第二个Add(1, 2.2)来说，却去调用了函数模版，因为第二个参数是【double】类型，普通的函数它也接不住呀，此时模版参数就可以根据这个类型来进行一个自动推导

③ 模板函数不允许自动类型转换，但普通函数可以进行自动类型转换

• 首先对于普通函数而言很好理解，看到print函数的形参所给的类型为【int】，但是在外界传入了一个【double】类型的数值，如果你学习过 隐式类型转换 的话，就可以知道这个浮点数传入的话会发生一个转换，这就叫做【自动类型转换】

  // 普通函数，允许自动类型转换
  void print(int value) {
      std::cout << "Integer: " << value << std::endl;
  }
  
  int main() {
      print(3);	
      print(3.14); 
      return 0;
  }
  

• 但是呢，对于模版函数来说是无法进行自动类型转换的，例如下面这个，我为这个函数模版定义了一个模版参数，但是在外界进行传递的时候却传递进来两种数据类型，为【int】或【double】，那么一个模版参数T就使得编译器无法去进行自动推导

  template <class T>
  void print(T a, T b) {
      cout << a << " " << b << endl;
  }
  
  int a = 1;
  double b = 1.11;
  
  print(a, b);
  

• 这个其实我们在上面也讲到过，再来回顾一下，改进的方法有两种，一个是【强制类型转换】，还记得罚站的事情吗；另一个则是【显式实例化】，还记得我们看的汇编吗

  // 强制类型转换
  print(a, (int)b);
  print((double)a, b);
  // 显式实例化
  print<int>(a, b);
  print<double>(a, b);
  

• 其实还有一种改进的方法，那就是增加模版参数，因为一个模版参数接收两种类型是无法进行自动推导的，此时若是有两个模版参数的话就可以接收两种类型了，不会出现错误

三、类模版

讲完了函数模版后，我们再来说说类模版，也就是对一个类来说，也是可以定义为一个模版的

1、类模板的定义格式

template<class T>
Stack<T>::Stack(size_t capacity)
{
	_array = new T(capacity);
	_capacity = capacity;
	_size = 0;
}