C++模板初阶

1. 泛型编程

前面我们讲了函数重载，可以用函数重载来实现多个不同参数类型的swap交换函数

#define _CRT_SECURE_NO_WARNINGS 1
#include<iostream>using namespace::std;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;
}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++中，也能够存在这样一个模具，通过给这个模具中填充不同材料(类型)，来获得不同材料的铸件 (即生成具体类型的代码），那将会节省许多头发。巧的是前人早已将树栽好，我们只需在此乘凉。泛型编程：编写与类型无关的通用代码，是代码复用的一种手段。模板是泛型编程的基础。

模板分为函数模板和类模板

2. 函数模板

2.1 函数模板概念

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

2.2 函数模板格式

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

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

注意：typename是用来定义模板参数关键字，也可以使用class(切记：不能使用struct代替class)

下面我们来看一段代码，看看模板怎么使用叭。

template<typename T>
void Swap(T& left, T& right)
{T temp = left;left = right;right - left;
}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;
}

可以看到都交换完成了。

2.3 函数模板的原理

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

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

2.4函数模板的实例化

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

2.4.1. 隐式实例化：

让编译器根据实参推演模板参数的实际类型

这样子正常使用是没问题的哦，下面我们再写一段代码看看会不会出现问题

template<typename T>
T Add(const T& left,const T& right)
{return left + right;}int main()
{int a1 = 10, a2 = 20;double b1 = 10.0, b2 = 20.0;Add(a1, a2);Add(b1, b2);cout << Add(a1, a2) <<endl;cout << Add(b1, b2) <<endl;return 0;
}

暂时还没问题哦

怎么我们把int和double类型混合起来加呢，

Add(a1, b1);
Add(a2, b1);

可以看到Add模板函数没有生成与表达式相匹配的函数

模板参数的推演出现了问题，这个时候我们要怎么解决呢？

方法一：强制类型转换

缺点：浮点型强制转换为整型会有精度的丢失哦


template<typename T>
T Add(const T& left, const T& right)
{return left + right;}//强制内置转换
Add(a1, (int)b2);
Add((double)a1, b2);
cout << Add(a1, (int)b2) << endl;
cout << Add((double)a1, b2) << endl;

2.4.2 显式实例化：

方法二：

在函数名后的<>中指定模板参数的实际类型

 //显式实例化Add<int>(a1, b2);Add<double>(a1, b2);cout << Add(a1, (int)b2) << endl;cout << Add((double)a1, b2) << endl;

可以以直接在cout里面显式实例化

cout << Add<int>(a1, b2) << endl;
cout << Add<double>(a1, b2) << endl;

我显式实例化指定的模板参数T类似是int,就是int，double就是double以此类推

不需要编译器自己去推演，这里还有隐式类型转换的加入

d2隐式类型转换为int，a1隐式类型转换为double

这个时候我们有一个想法，如果我们给两个模板参数不就可以解决了嘛？

给两个模板参数确实可以解决，但是面对的问题是返回的地方是T1，还是T2

当T1作为返回值的时候：

解决办法就是使用auto 作为返回值，让编译器自己推导返回值

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

也就是这里不能使用auto

2.5模板的有限匹配原则

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

优先匹配适合自己的，没有适合自己的凑合的模板函数也可以

打一个比方，今天没人在家但是妈妈留了中午饭（模板函数成品），如果没有（模板函数成品），家里面有冷冻饺子（模板函数半成品）

// 专门处理int的加法函数
int Add(const int& left, const int& right)
{cout << " Add(const int& left, const int& right) "<<endl;return left + right;
}//通用双模板参数的加法函数
template<typename T1,typename T2>
auto Add(const T1& left, const T2& right)
{cout << "auto Add(const T1& left, const T2& right) " << endl;return left + right;}//通用模板加法函数
template<typename T>
T Add(const T& left, const T& right)
{cout << "T Add(const T& left, const T& right) " << endl;return left + right;}

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

int main()
{int a1 = 10, a2 = 20;double b1 = 10.1, b2 = 20.1;/* Add(a1, a2);Add(b1, b2);*/cout << Add(a1, a2) <<endl;// 与非模板函数匹配，编译器不需要特化cout << Add(b1, b2) <<endl;//强制内置转换/* Add(a1, (int)b2);Add((double)a1, b2);*/cout << Add(a1, (int)b2) << endl;cout << Add((double)a1, b2) << endl;//显式实例化/*Add<int>(a1, b2);Add<double>(a1, b2);*/cout << Add<int,double>(a1, b2) << endl;cout << Add<int,double>(a1, b2) << endl;cout << Add(a1, b2) << endl;return 0;
}

2.6必须使用模板的显式实例化的情况

class A
{
public:A(int a ):_a(a){}private:int _a;
};template <typename T>
T* func(int a)
{//operator new 申请一个空间T* p1 = (T*)operator new(sizeof(T));//显式调用构造new(p1)T(a);return p1;}int main()
{//这句的代码是错误的func(1)；return 0;
}

不能用返回值来推导T的类型，因为可以不写返回值

这个时候模板的显式实例化就派上场了。

int main()
{int* ret1 = func<int>(1);A* ret2 = func<A>(1);return 0;
}

3. 类模板

3.1 类模板的定义格式

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

class 模板类名

{

//类成员定义

}

以前我们写类的时候，是不是一个类只能是一个类型，多个类型就需要写多个不同类型的类

现在有了函数模板就方便多了

// 类模版
template<typename T>
class Stack
{
public:Stack(size_t capacity = 4){_array = (T*)malloc(sizeof(T) * capacity);if (nullptr == _array){perror("malloc申请空间失败");return;}_capacity = capacity;_size = 0;}void Push(const T& data)
{// 扩容_array[_size] = data;++_size;
}
private:T* _array;size_t _capacity;size_t _size;
};int main()
{Stack<int> st1;    // intStack<double> st2; // doublereturn 0;
}

类模板的声明与定义分离，特别要注意

// 注意：类模板中函数放在类外进行定义时，需要加模板参数列表

// 模版不建议声明和定义分离到.h 和.cpp会出现链接错误，具体原因后面会讲
// 要分离也分离在.h
template<class T>
void Stack<T>::Push(const T& data)
{
   // 扩容
   _array[_size] = data;
   ++_size;
}