模版初阶
1.泛型编程
如何实现一个通用的交换函数呢？
我们先来看一个情景：
假设我们需要一个交换的函数，在C语言，我们需要对每一个类型都重新编写一个不同的函数，名字也不能相同。而在c++支持重载后，虽然函数名可以相同，但是我们仍然要对每一种类型都编写一个函数。
比如int类要交换，那么形参就是int…
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;
}
使用函数重载虽然可以实现，但是有一下几个不好的地方：
-
重载的函数仅仅是类型不同，代码复用率比较低，只要有新类型出现时，就需要用户自己增加对应的函数
-
代码的可维护性比较低，一个出错可能所有的重载均出错
那能否告诉编译器一个模子，让编译器根据不同的类型利用该模子来生成代码呢？
在c++中恰好就有这么一种模子，能够根据你输入的类型，来生成对应类型的代码。
- 泛型编程：编写与类型无关的通用代码，是代码复用的一种手段。模板是泛型编程的基础。
模版有两种模版：
- 函数模版
- 类模版
2.函数模版
2.1 函数模板概念
函数模板代表了一个函数家族，该函数模板与类型无关，在使用时被参数化，根据实参类型产生函数的特定类型版本。
2.2函数模版格式
template<typename T1, typename T2,…,typename Tn>
返回值类型 函数名(参数列表){}
//template<typename T> // 模版也可以这样写
template<class T>// T也是一种类型，模版参数 类型
void Swap(T& x1, T& x2)
{
T tmp = x1;
x1 = x2;
x2 = tmp;
}
注意：typename是用来定义模板参数关键字，**也可以使用class(**切记：不能使用struct代替class)
2.3函数模版的原理
函数模板是一个蓝图，它本身并不是函数，是编译器用使用方式产生特定具体类型函数的模具。所以其实模板就是将本来应该我们做的重复的事情交给了编译器
// 注意，下面三次调用的函数是否是同一个函数?
// 不是，每次调用的都是函数模版实例化生成的对应类型的函数。
// 这个生成的过程，我们看不见，是编译器在预处理阶段自动帮我们生成的(不是调用时才生成，是预处理的时候已经生成完了)
// 这个过程叫做模版的实例化
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;
}
注意： 模版的实例化发生在预处理阶段
在编译器编译阶段，对于模板函数的使用，编译器需要根据传入的实参类型来推演生成对应类型的函数以供调用。比如：当用double类型使用函数模板时，编译器通过对实参类型的推演，将T确定为double类型，然后产生一份专门处理double类型的代码，对于字符类型也是如此
想要验证也很简单，我们只需要在调试的时候去观看其汇编语言就知道了。
可以看到三次调用Swap函数call的都是不同的函数
2.4函数模版的实例化
用不同类型的参数使用函数模板时，称为函数模板的实例化。模板参数实例化分为：隐式实例化和显式实例化
2.4.1隐式实例化
隐式实例化： 让编译器 根据调用模版的实参去推演出模板参数的类型
例子：
// 函数模版的隐式实例化
# include<iostream>
# include<typeinfo>
using namespace std;
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;
cout << Add(a1, a2) << endl; // 30
cout << Add(d1, d2) << endl; // 30
cout << typeid(Add(a1, a2)).name() << endl; // int
cout << typeid(Add(d1, d2)).name() << endl;// double
// 我们发现上面在调用函数模版的时候，编译器会自己推导出实参的类型给模版参数
// 但是下面这句代码就不行了
//Add(a1, d1);
/*
该语句不能通过编译，因为在编译期间，当编译器看到该实例化时，需要推演其实参类型
通过实参a1将T推演为int，通过实参d1将T推演为double类型，但模板参数列表中只有一个T，
编译器无法确定此处到底该将T确定为int 或者 double类型而报错
注意：在模板中，编译器一般不会进行类型转换操作，因为一旦转化出问题，编译器就需要背黑锅
*/
// 因此需要手动强制转化d1的类型，或者a1的类型。
Add(a1, int(d1));
return 0;
}
2.4.2显式实例化
显式实例化： 在函数名后边跟上<> , <>里边指定模版参数的实际类型
// 函数模版的显式实例化
# include<iostream>
# include<typeinfo>
using namespace std;
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;
cout << Add<int>(a1, a2) << endl; // 30
cout << Add<double>(d1, d2) << endl; // 30
cout << typeid(Add<int>(a1, a2)).name() << endl; // int
cout << typeid(Add<double>(d1, d2)).name() << endl;// double
// 在讲述隐式实例化的时候，我们发现一个问题，那就是编译器无法编译这句代码Add(a1, d1);
// 因此需要手动强制转化d1的类型，或者a1的类型。
Add(a1, int(d1));
// 但是我们还可以采取显式实例化的手段
Add<int>(a1, d1); // 编译器会自动将d1 隐式类型的转换，将d1转化成int类型、
return 0;
}
2.5模版参数的匹配原则
- 一个非模板函数可以和一个同名的函数模板同时存在，而且该函数模板还可以被实例化为这个非模板函数
// 模版函数和函数之间的优先级匹配
int Add(const int& left, const int& right)
{
return left + right;
}
template<class T>
T Add(const T& left, const T& right)
{
return left + right;
}
int main()
{
Add(1, 2); // 优先调用int Add，因为可以少一步实例化的步骤
Add<int>(1, 2);// 指明要实例化, 调用函数模版
return 0;
}
也可以通过调试去验证调用的到底是函数模版还是函数
- 对于非模板函数和同名函数模板，如果其他条件都相同，在调动时会优先调用非模板函数而不会从该模板产生出一个实例。如果模板可以产生一个具有更好匹配的函数， 那么将选择模板
// 通用加法函数
int Add(const int& left, const int& right)
{
return left + right;
}
template<class T1, class T2>
T1 Add(T1 left, T2 right)
{
return left + right;
}
int main()
{
Add(1, 2); // 与非函数模板类型完全匹配，不需要函数模板实例化
Add(1, 2.0); // 模板函数可以生成更加匹配的版本，编译器根据实参生成更加匹配的Add函数
return 0;
}
- 普通函数允许自动类型转换，模板函数不允许自动类型转换
代码如上图所示：
上述两个函数调用的都是同一个函数，并且2.0会被隐式类型转换成int类型
看汇编语言可以知道，调用的都是同一个函数
3.类模版
3.1 类模板的定义格式
template<class T1, class T2, ..., class Tn>
class 类模板名
{
// 类内成员定义
};
跟函数模版一样，类模版并不是真正的类，而是一个模版，会根据调用该模版所传入的类型进行类模版的实例化，生成对应类型的类
来看一个例子：
// 类模版
// 动态顺序表
// 注意：vector不是具体的类，是编译器根据被实例化的类型生成具体类的模具
# include <stdio.h>
# include<assert.h>
# include<string.h>
# include<iostream>
using namespace std;
template<class t>
class vector // c++管顺序表叫vector
{
public:
// 无参构造函数
vector()
: _pdata(nullptr)
, _size(0)
, _capacity(0)
{}
// 带参构造函数
vector(size_t capacity)
: _pdata(new t[capacity])
, _size(0)
, _capacity(capacity)
{}
// 使用析构函数演示：在类中声明，在类外定义。
~vector();
void pushback(const t& data);
void popback();
size_t size()
{
return _size;
}
t& operator[](size_t pos) // 引用的目的是 外界在修改数据的时候不会报错。并且可以提高效率，减少拷贝构造
{
assert(pos < _size && pos >= 0);
return _pdata[pos]; // 也可以是 this->_pdata[pos]
}
private:
t* _pdata;
size_t _size;
size_t _capacity;
};
// 注意：类模板中函数放在类外进行定义时，需要加 模板参数列表
template <class t>
vector<t>::~vector() // vector<t>才是类 vector是类的模版名
{
if (_pdata)
delete[] _pdata;
_pdata = nullptr;
_size = _capacity = 0;
}
template<class t>
void vector<t>::pushback(const t& data)
{
//判断空间是否足够
if (_size == _capacity)
{
size_t newcapacicy = _capacity == 0 ? 2 : _capacity * 2;
t* tmp = new t[newcapacicy];
if (_pdata) // 判断之前是否有数据
{
// 有数据要拷贝到新数组中
memcpy(tmp, _pdata, sizeof(t) * _size);
delete[] _pdata;
}
_capacity = newcapacicy;
_pdata = tmp;
}
// 尾插
_pdata[_size] = data;
_size++;
}
template<class t>
void vector<t>::popback()
{
assert(_size > 0);
_size--;
}
int main()
{
vector<int> v;
v.pushback(1);
v.pushback(2);
v.pushback(3);
v.pushback(4);
for (int i = 0; i < v.size(); i++)
{
// 这里能使用[]是因为我们重载了[]运算符
cout << v[i] << " "; // v.operator[](&v, i)
// 重载了之后，就能够让我们的自定义类型，像内置类型那样去使用
}
cout << endl;
for (int i = 0; i < v.size(); i++)
{
v[i] *= 2; //这里是对顺序表的数据进行修改，因此我们[]的重载的返回值需要是引用
// 不然返回的是临时变量，具有常性，无法修改。
}
for (int i = 0; i < v.size(); i++)
{
cout << v[i] << " "; // v.operator[](&v, i)
}
cout << endl;
return 0;
}
3.2类模版的实例化
类模板实例化与函数模板实例化不同，类模板实例化需要在类模板名字后跟<>，然后将实例化的类型放在<>中即可，类模板名字不是真正的类，实例化的后的类才是真正调用的类
// Vector类名，Vector<int>才是类型
Vector<int> s1;
Vector<double> s2;
3.3思考
其实我们思考一个问题，c++的出现就是为了解决c语言的一些问题。
假设我们要实现一个Stack类，那么在C语言中就会存在如下这些问题：
- 容易忘记初始化和销毁，因为C语言中需要手动调用 初始化和销毁的接口
- 外界可以随便访问或者修改结构体中的数据
- C语言无法实现 同时定义两个栈，一个存int类，一个存double类
在C++中我们是如何解决这些问题的呢？
- C++通过 构造函数和析构函数 解决
- C++通过 类 + 访问限定符 解决
- C++通过 类模版 解决
// 类模版
template<class T>
class Stack_cpp
{
public:
Stack_cpp()
{
//......
}
~Stack_cpp()
{
//......
}
// 接口......
void StackPush(const T& x)
{
}
private:
T* _a; // 根据给的类型来灵活决定
int _size;
int _capacity
};
int main()
{
Stack_cpp<int> st_cpp_int; // 要注意给模组参数一个实参，代表这个栈存放int类的数据
st_cpp_int.StackPush(1);
st_cpp_int.StackPush(2);
Stack_cpp<double> st_cpp_double; // 该栈存放double类型的数据
st_cpp_double.StackPush(1.1);
st_cpp_double.StackPush(1.2);
return 0;
}
总结：
- 函数模版不是函数，类模版也不是类
- 模版会在预处理阶段的时候根据，代码中调用模版的类型去实例化出对应的函数和类。
因此到了编译的阶段，编译器是看不到模版的，因为在预处理阶段就已经实例化出对应的函数和类了。编译器在编译的时候，看到的就是实例化出来的函数和类。
- 并不是有了模版就不需要写对应类型和函数和类了，只是有了模版是编译器去帮我们写，没有模版我们需要自己写
如图所示：
