目录
编辑
一、泛型编程
二、函数模板
1.概念
2.格式
3.原理
4.匹配原则
三、类模板
1.定义格式
2.类模板的实例化
一、泛型编程
泛型编程是一种编程范式，它允许在编写代码时使用一种通用的数据类型或算法，以便在不同的数据类型上进行操作，而不需要为每种数据类型编写专门的代码。泛型编程的目标是提高代码的重用性和可扩展性。
当我们想对不同的类型实现交换函数，我们以前的做法是写多个重载函数：
int Swap(int& a, int& b)
{
int temp = a;
a = b;
b = temp;
}
void Swap(double& a, double& b)
{
double temp = a;
a = b;
b = temp;
}
使用函数重载虽然可以实现，但是有一下几个不好的地方：
-
重载的函数仅仅是类型不同，代码复用率比较低，只要有新类型出现时，就需要用户自己增加对应的函数
-
代码的可维护性比较低，一个出错可能所有的重载均出错
当我写代码时就想着，要是编译器能够自动识别出类型套用到函数里去就好了。
但是现在，实现了！！！
有请出我们的模板：
二、函数模板
1.概念
2.格式
template<typename T>
void Swap(T a, T b)
{
T temp = a;
a = b;
b = temp;
}3.原理
模板本身不能调用，模板是生成具体的函数
在编译器编译的时候，编译器会根据实参传给形参来推断对应的类型，再用对应的类型来生成函数。
template<typename T>
void Swap(T a, T b)
{
T temp = a;
a = b;
b = temp;
}
int main()
{
int a = 1, b = 2;
double da = 1.3, db = 1.6;
Swap(a, b);
Swap(da, db);
return 0;
}所以在这里，a、b和da、db它们所调用的函数不是同一个函数。而是编译器根据推导的类型会生成相应的类型函数。
那如果我们将俩个不同类型的传入Swap模板呢？
可以看到编译器报错了。
但如果我们就想传不同类型应该怎么办呢？
用函数模版生成对应的函数 -> 模版的实例化
方法1：推导实例化
template<typename T>
void Swap(T a, T b)
{
T temp = a;
a = b;
b = temp;
}
int main()
{
int a = 1, b = 2;
double da = 1.3, db = 1.6;
Swap(a, b);
Swap(da, db);
//1.推导实例化
Swap(a, (int)da);
Swap((double)b, db);
return 0;
}方法2：显示实例化
template<typename T>
void Swap(T a, T b)
{
T temp = a;
a = b;
b = temp;
}
int main()
{
int a = 1, b = 2;
double da = 1.3, db = 1.6;
//隐式实例化:让编译器根据实参推演模板参数的实际类型
Swap(a, b);
Swap(da, db);
//1.推导实例化
Swap(a, (int)da);
Swap((double)b, db);
//2.显示实例化:在函数名后的<>中指定模板参数的实际类型
Swap<int>(a, da);
return 0;
}在显示实例化中，如果类型不匹配，编译器会进行隐式类型转换。如果无法转换，则编译器会进行报错。在上面的例子中，编译器就对da进行了隐式类型转换，转换成int类型的数据。
方法3：
当你就是不想进行任何的转换，那么这时你还可以对模板进行修改，修改成多参数模板：
template<typename T1,typename T2>
void Swap(T1 a, T2 b)
{
T1 temp = a;
a = b;
b = temp;
}
int main()
{
int a = 1;
double da = 1.1;
Swap(1, 1.1);
return 0;
}注：当类型T没有在函数的形参中出现时，必须进行显示实例化：
template<class T>
T* func(int n)
{
return new T[n];
}
int main()
{
func<int>(1);
return 0;
}这是因为，编译器无法通过实参传给的形参来判断类型，所以必须明确指出类型给编译器。
4.匹配原则
1. 一个非模板函数可以和一个同名的函数模板同时存在，而且该函数模板还可以被实例化为这
个非模板函数
2. 对于非模板函数和同名函数模板，如果其他条件都相同，在调动时会优先调用非模板函数而
不会从该模板产生出一个实例。如果模板可以产生一个具有更好匹配的函数， 那么将选择模
板
3. 模板函数不允许自动类型转换，但普通函数可以进行自动类型转换
template<class T>
void Swap(T a, T b)//1
{
T temp = a;
a = b;
b = temp;
}
void Swap(int a, int b)//2
{
int temp = a;
a = b;
b = temp;
}
template<class T1,class T2>
void Swap(T1 a, T2 b)//3
{
T1 temp = a;
a = b;
b = temp;
}
int main()
{
int a = 1, b = 2;
double da = 1.1, db = 2.2;
Swap(a, b);//与非模板函数匹配，走第二个
Swap<int>(a, b);//指明要用模板，走第一个
Swap(da, db);//比起非模板函数，T1、T2模板更加匹配，走第三个
return 0;
}三、类模板
1.定义格式
template<class T1, class T2, ..., class Tn>
class 类模板名
{
// 类内成员定义
};用栈举一个类模板的例子：
template<typename T>
class Stack
{
public:
Stack(int n=4)
:_arr(new T[n])
,_capacity(0)
,_size(0)
{
}
void Push(const T& data)
{
if (_size == _capacity)//当栈已经满了的时候
{
T temp = new T[_capacity * 2];
memcpy(temp, _arr, sizeof(T) * _size);//这一步类似于以前的realloc
delete[]_arr;
_arr = temp;
_capacity *= 2;
}
_arr[_size++] = data;
}
private:
T* _arr;
int _capacity;
int _size;
};
int main()
{
Stack<int>s1;
s1.Push(1);
s1.Push(2);
Stack<double>s2;
s2.Push(1.1);
s2.Push(2.2);
return 0;
}一个模板对应一个类或者函数，所以当我们想将类里面的函数放在类外面来进行使用，那必须重新为这个函数写一个模板，如下：
template<typename T>
class Stack
{
public:
Stack(int n = 4)
:_arr(new T[n])
, _capacity(0)
, _size(0)
{
}
void Push(const T& data);
private:
T* _arr;
int _capacity;
int _size;
};
template<class T>
void Stack<T>::Push(const T& data)
{
if (_size == _capacity)//当栈已经满了的时候
{
T temp = new T[_capacity * 2];
memcpy(temp, _arr, sizeof(T) * _size);//这一步类似于以前的realloc
delete[]_arr;
_arr = temp;
_capacity *= 2;
}
_arr[_size++] = data;
}
int main()
{
Stack<int>s1;
s1.Push(1);
s1.Push(2);
Stack<double>s2;
s2.Push(1.1);
s2.Push(2.2);
return 0;
}注意：模板不建议将声明和定义分离到两个文件
2.类模板的实例化
类模板实例化与函数模板实例化不同，类模板实例化需要在类模板名字后跟<>，然后将实例化的
类型放在<>中即可，类模板名字不是真正的类，而实例化的结果才是真正的类。
// Stack是类名，Stack<int>才是类型
Stack<int> st1; // int
Stack<double> st2; // double如果这篇文章有帮助到你，请留下您珍贵的点赞、收藏+评论，这对于我将是莫大的鼓励！学海无涯，共勉！😘😊😗💕💕😗😊😘
