C++初阶-模板初阶

1.泛型编程

2.函数模板

2.1函数模板概念

2.2实现函数模板

2.3模板的原理

2.4函数模板的实例化

2.4.1隐式实例化

2.4.2显式初始化

2.5模板参数的匹配原则

3.类模板

3.1类模板定义格式

3.2类模板的实例化

4.总结

1.泛型编程

对广泛的类型法写代码，我们之前写的是一个专用的类型，如果想要用其他类型就要再写一个专用的函数写这个功能和实现方式与其他的差不多的代码，非常麻烦，如：

//交换两个整型
void Swap(int& a, int& b)
{int c = a;a = b;b = c;
}
//交换两个浮点型
void Swap(double& a, double& b)
{double c = a;a = b;b = c;
}

我们可以发现，如果我们把第一个函数的int 改为double就可以直接变为第二个函数了，这样写起来很费时间，而且如果我们这个函数只用几次的话，写了这个是完全没意义的，所以这有两个不好的地方：

（1）重载的函数仅仅是类型不同，代码复用率比较低，只要有新类型出现时，就需要用户自己增加对应的函数；

（2）代码的可维护性比较低，一个出错可能所有的重载均出错。

我们能否告诉编译器一个模子，让编译器根据不同的类型利用该模子来生成代码呢？

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

而这就需要我们来通过模板这个东西来实现，模板分为函数模板和类模板。

2.函数模板

2.1函数模板概念

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

2.2实现函数模板

模板的格式：template<typename T1,typename T2,……,typedname Tn>

其中T1、T2、……T3都是模板的参数，而这个template是关键字，typename是用来定义模板参数关键字，也可以使用class（切记不可用struct代替）。（到模板进阶（C++初阶最后的部分）会讲class与typename的区别）

如，我们之前实现的交换函数可以这样写：

#include<iostream>
using namespace std;
//需要几个类型就写几个参数
template<typename T>
void Swap(T& left, T& right)
{T temp = left;left = right;right = temp;
}
int main()
{//交换两个整型int a, b;cin >> a >> b;Swap(a, b);cout << a << " " << b << endl;//交换两个浮点型double c, d;cin >> c >> d;Swap(c, d);cout << c << " " << d << endl;//交换两个字符型char e, f;cin >> e >> f;Swap(e, f);cout << e << " " << f << endl;return 0;
}

运行结果如下：

如果我们实参不是一个类型，则会报错：

我们相较于之前写交换函数只是在函数定义前加了一行模板的定义而已，并且把类型换为模板了而已。

2.3模板的原理

函数模板是一个蓝图，它本身并不是函数，是编译器用使用方式产生特定具体类型函数的模具。
所以其实模板就是将本来应该我们做的重复的事情交给了编译器。只是看实参类型用模板去匹配而已，实际上生成的两个函数都不是一样的，编译器根据实参类型生成一个新函数，如果有不同的类型就再生成一个新函数，地址不同。如，我们之前实现的交换函数：

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

2.4函数模板的实例化

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

2.4.1隐式实例化

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

和我之前实现的那个交换函数调用时一样的形式，int a,b;Swap(a,b);则通过自动识别出a和b都是int类型，这就是隐式实例化。

但是如果我们给的是不同的类型，通过识别出两个实参类型不同就会报错，这个时候我们要么就改实参为同一类型，要么就用显式实例化，要么就要一个类型强制类型转换为另一类型：

#include<iostream>
using namespace std;
template<class T>
T Add(const T& left, const T& right)
{return left + right;
}
int main()
{int a = 3, b = 2;double c = 3.024, d = 4.501;cout << Add(a, b) << endl;cout << Add(c, d) << endl;cout << Add(a, (int)c) << endl;cout << Add((double)a, c) << endl;return 0;
}

运行结果如下：

建议不要去运行之前的交换排序代码，因为它我测试过不仅显式实例化没有用处，强制类型转换也没有用处，至于原因感兴趣的可以去探讨一下。

当然这里涉及到精度丢失的问题，所以建议Add这类的函数还是加一个参数写成如下形式：

但是返回值你也要改一下，要么返回double类型要么返回int类型！

template<class T1,class T2>
T1 Add(const T1& left, const T2& right)
{return left + right;
}

这是一个演示的，如果之后学的更多了，也可能会有其他类型的返回值等等。

2.4.2显式初始化

我们之前的代码也可以改为如下形式，这样的形式也不用强制类型转换了，直接用<>里面的类型进行生成函数的操作。

#include<iostream>
using namespace std;
template<class T>
T Add(const T& left, const T& right)
{return left + right;
}
int main()
{int a = 2, b = 3;double c = 4.53, d = 2.54;//指定参数为int类型（形参）cout << Add<int>(a, c) << endl;//指定参数为double类型（形参）cout << Add<double>(b, d) << endl;return 0;
}

运行结果如下：

当然，运行时输出的会有一个提示：

也就是说double转换为int会有小数点后的数据丢失，所以建议把int转换为double类型！因为这样算出来的结果才更加准确。

当然不是所有的都可以用两种实例化的方式：

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

因为形参没有任何的能代表T的类型，也就是说不能通过类型推理来知道T的类型，所以就只能进行显式实例化了。

2.5模板参数的匹配原则

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

如：

// 专门处理int的加法函数
int Add(int left, int right)
{return left + right;
}// 通用加法函数
template<class T>
T Add(T left, T right)
{return left + right;
}void Test()
{Add(1, 2);       // 与非模板函数匹配，编译器不需要特化Add<int>(1, 2);  // 调用编译器特化的Add版本
}

若有int类型的，编译器会先用现成的（非模板），否则用模板的。但若我们不想用现成的我们就可以直接显式实例化。

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

如：

#include<iostream>
using namespace std;
// 专门处理int的加法函数
int Add(int left, int right)
{return left + right;
}// 通用加法函数
template<class T1, class T2>
T1 Add(T1 left, T2 right)
{return left + right;
}void Test()
{Add(1, 2);// 与非函数模板类型完全匹配，不需要函数模板实例化Add(1, 2.0);// 模板函数可以生成更加匹配的版本，编译器根据实参生成更加匹配的
}

只要非模板函数的形参类型与实参全部匹配就用非模板函数，但是如果是两个参数类型不一样的情况，发现模板函数用的不会使精度丢失，所以直接用了模板函数了。

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

3.类模板

3.1类模板定义格式

template<class T1, class T2, ..., class Tn>
class 类模板名
{
// 类内成员定义
};

和之前的方式一样，当然，不是因为它是类就只能用class来定义参数，也可以用typename定义参数，只是现在没学到后面，不知道二者的区别而已。

我们可以把之前实现栈来改为这个方式：

#include<iostream>
using namespace std;
// 类模版
template<typename T>
class Stack
{
public:Stack(size_t capacity = 4){_array = new T[capacity];_capacity = capacity;_size = 0;}void Push(const T& data);
private:T* _array;size_t _capacity;size_t _size;
};
// 模版不建议声明和定义分离到两个文件.h 和.cpp会出现链接错误，具体原因后面会讲
template<class T>
void Stack<T>::Push(const T& data)
{// 扩容_array[_size] = data;++_size;
}

我们定义这个栈的时候如果成员函数声明和定义分离时不能忘记加这一行模板了，否则会出现：

3.2类模板的实例化

Stack<int> st1; // int
Stack<double> st2; // double

由于类模板不能通过隐式实例化来确定形参类型，所以必须用显式实例化，且注意：Stack是类名，Stack<int>是类型。

其次再补充一下之前的：

template<class T>
void Stack<T>::Push(const T& data)
{// 扩容_array[_size] = data;++_size;
}

模板参数不能是凭空出来的，故指定类域得加模板参数，否则T是用不了的，因为模板是给Stack类用的模板参数，因为模板参数是属于这个Stack类型，因为T可以为任意类型，若去掉，则本质上Push要实例化出多个，这样就不行了。

4.总结

这是模板初阶的东西，所以很多东西是没有讲解完全的，需要到模板进阶来讲清楚，但是模板进阶要很晚了，下面这张图片是C++初阶的全部内容，所以我们现在已经C++初阶过了一半了，之后难度会比较高（第8节开始），所以需要深入学习也需要持之以恒哦！

加油吧，相信自己能学会才是最好的安慰！喜欢的可以一键三连哦，下一节很简单，所以应该很快就发出来的！