前言
假如需要你写一个交换函数，交换两个相同类型的值，这时如果交换的是int 类型的值，你可能会写一个Swap函数，其中参数是两个int类型的，假如再让你写一个double类型的呢？你可能又要写一个Swap的函数重载，参数是两个类型double的，假如再让你写一个char类型的呢？你可能……这样会有尽头吗？没有，因为还有自定义类型呢！那我们如何解决这样的问题呢？——模板（主要功能是实现通用）
- 补充：泛型编程：编写与类型无关的通用代码，是代码复用的一种手段。模板是泛型编程的基础。
一. 函数模板
基本用法
①定义模板参数类型名
template<typename T1, typename T2,......,typename Tn>
//这里的typename也可以换为class
template<class T1, class T2,......,class Tn>
- 切记： 不能换为struct
②函数模板的实现
- 比如我们实现一个交换函数的模板
template<typename T>
void Swap(T& n1, T& n2)
{
T tmp = n1;
n1 = n2;
n2 = tmp;
}
用如下几个例子实验一下：
例1：
class Date
{
public:
void Print()
{
cout << _year << "年" << _month << "月" << _day << "日" << endl;
}
Date(int year,int month,int day)
:_year(year)
,_month(month)
,_day(day)
{
}
private:
int _year;
int _month;
int _day;
};
int main()
{
int x = 0,y = 1;
double x1 = 1.1, y1 = 2.2;
Date x2(1949, 10, 1), y2(2023, 5, 23);
Swap(x, y);
Swap(x1, y1);
Swap(x2, y2);
x2.Print();
y2.Print();
cout << "x:" << x << " y:" << y << endl;
cout << "x1:" << x1 << " y1:" << y1 << endl;
return 0;
}
运行结果：
- 可以看到这是交换了。
到这里我们又有一个疑问——调用的是一个函数吗？
继续分析——转到反汇编。
- 可以看到——调用的Swap的地址是不一样的！
- 因此：调用的不是一个函数。
- 如何解释呢？
换汤不换药，换的是类型，不变的交换的思想。
图解：
其实我们也跟根本不用自己实现交换函数，直接用库里的就行了。
- 不过库里的是全小写，我们平常实现的是首字母大小。
③模板的实例化
隐式实例化
- 让编译器根据实参推演模板参数的实际类型。
template <typename T>
T Func(const T& n1, const T& n2)
{
return n1 + n2;
}
int main()
{
int x = 0,y = 1;
Func(x, y);
return 0;
}
- 就好比这里传参并没有明确的说明x的类型，但是编译器会自动推导实参的类型。
显示实例化
- 在函数名后的<>中指定模板参数的实际类型
template <typename T>
T Func(const T& n1, const T& n2)
{
return n1 + n2;
}
int main()
{
int x = 0,double y = 1;
Func<int>(x, y);
//这里会将y强制类型转换为一个double类型的常量，因此函数参数的const不可省去。
return 0;
}
- 像这样如果，编译器推导不出来类型，这时就需要我们显示声明一下，其中的类型是什么，否则编译器会直接报错。
- 那除了显示示例化还有什么办法么？——强制类型转换。
template <typename T>
T Func(const T& n1, const T& n2)
{
return n1 + n2;
}
int main()
{
int x = 0,double y = 1;
Func(x, (int)y);
//这里会将y强制类型转换为一个double类型的常量，因此函数参数的const不可省去。
return 0;
}
- 强转的结果必然是使两个参数类型保持一致，如果强转后的参数类型不一致，那么编译器还是会报错。
还有一种情况是我们必须显示示例化的——模板参数做返回值。
示例：
template <typename T>
T Func(int x, int y)
{
return x + y;
}
int main()
{
int x = 0;
int y = 1;
Func<int>(x,y);
return 0;
}
- 这就好比你要使用函数模板，得先让编译器知道或者能推导出模板参数的类型，那么返回值写上模板参数的话，编译器是无从下手的，那么只有显式实例化了，编译器才知道返回类型，才会给你生成指定类型的函数。
④函数模板与普通函数的调用规则
1.能用普通函数就用普通函数，用不了再用函数模板。
int add(int x, int y)
{
return x + y;
}
template <typename T1,typename T2>
int add(T1 x, T2 y)
{
return x + y;
}
int main()
{
add(1, 2);//这里调用的非模板
add(1.0, 1);//这里使用的是模板生成的函数
return 0;
}
看反汇编：
2.非模板函数与模板部分重复都可以使用。
int add(int x, int y)
{
return x + y;
}
template <typename T1,typename T2>
int add(T1 x, T2 y)
{
return x + y;
}
int main()
{
add(1, 2);//这里是调用add函数，因为能用普通函数就用普通函数
add<int>(1, 1);这里是用的add模板函数实例化生成的函数。
//这样也可以
add<>(1, 1);//这算是空模板，只是为了调用模板而已。
return 0;
}
3.普通函数支持类型转换，而模板要严格按照类型。
template<typename T>
int myAdd(T a, T b)
{
cout << "template function" << endl;
return a + b;
}
int myAdd(char a, char b)
{
cout << "normal function" << endl;
return a + b;
}
void test()
{
int a = 10;
int b = 20;
char c1 = 'a';
char c2 = 'b';
myAdd(a, c1);//这里调用的是函数，这里的a会自动转换为char类型的
myAdd(a, b);//两个都是int类型的调用模板函数
myAdd(c1, b);//这里会发生类型转换，b的int类型会转换为char类型的
myAdd(c1, c2);
myAdd<>(c1, c2);//这里是显示实例化，自然会调用函数模板
}
int main()
{
test();
return 0;
}
- 总结：
1.普通函数优先调用
2.普通函数支持类型转换
3.模板必须严格的类型匹配
4.如果函数模板可以产生一个更好的匹配，那么选择模板。
5.可以用空模板或者模板实例化让编译器只调用模板
二. 类模板
- 简而言之就是类是通用的，比如一个栈既要存int类型的，又要存double类型等等。
- 说明：类模板不是具体的类，是用来生成类对象的模具。
- 补充：template定义的模板参数只在最近的一个大括号内有效。
#include<iostream>
using namespace::std;
template <typename T>
class Stack
{
public:
Stack(int capacity = 4)
{
cout << "Stack()" << endl;
T* tmp = new T[capacity];
_arr = tmp;
_top = 0;
_capacity = capacity;
}
void PushBack(T x);
private:
T* _arr;
int _top;
int _capacity;
};
//这里放在类外进行定义。
template <typename T>
//这里要说明的是必须写Stack<T>这是具体的类，而不能只写Stack。
void Stack<T>::PushBack(T x)
{
if (_top == _capacity)
{
T* tmp = (T*)realloc(_arr, sizeof(T) * _capacity * 2);
if (tmp == NULL)
{
perror("realloc fail");
exit(-1);
}
else
{
_arr = tmp;
_capacity *= 2;
}
}
_arr[_top++] = x;
}
int main()
{
Stack<int> stack1;//这要说明使用的数据类型，也就是类模板示例化。
return 0;
}
// 注意：类模板
//1.类名——Stack
//2.类型 ——Stack<T>
- 由类模板实例化得到的类叫模板类
