前言

假如需要你写一个交换函数，交换两个相同类型的值，这时如果交换的是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>

• 由类模板实例化得到的类叫模板类