C/C++基础--C++模板

为了解决函数重载带来的代码重复性高，过度冗余并且可维护性低的缺点	

在C++中提供两种模板：函数模板与类模板

模板概述

提供模具

c++面向对象编程思想：封装、继承、多态
c++泛型编程思想：模板

将功能相同，类型不同的函数(类)的类型抽象成虚拟的类型。当调用函数(类实例化对象)的时候，编译器自动将虚拟的类型具体化。这就是函数模板(类模板)。

函数模板

定义方式

模板的关键字template ，模板中的typename也可以用class来代替

template<typename T1, typename T2,......,typename Tn>
返回值类型 函数名(参数列表)
{
   
    //……
}

例如：我们在这里用普通函数定义一个交换方法

void Swap(int &a,int &b)
{
   
	int temp = a;
	a = b;
	b = temp;
}

这个交换函数套用函数模板如下所示

template<typename T> //template<class T>
void Swap(T &a,T &b)
{
   
	T temp = a;
	a = b;
	b = temp;
}

函数模板具体汇编两次：
1.对函数模板本身进行编译
2.函数调用处，将T的类型具体化（函数调用时，会根据实参的类型，自动推导T的类型）
函数模板的目标：为了实现泛型，减轻编程的工作量，增强函数的重用性。

针对下述代码

template<typename T>
void swapAll(T &a,T &b)
{
   
	T tmp = a;
	a = b;
	b = tmp;
	return;
}

int main()
{
   
	int a = 10, b = 20;
	swapAll(a, b);

	char a1 = 'a', b1 = 'b';
	swapAll(a1, b1);
	return 0;
}

函数调用时，会根据实参的类型，自动推导T的类型,SwapAll函数根据不同的类型通过模板定制专属类型函数，之后再调用，如下图：

注意点

函数模板 与 普通函数都识别（优先选择 普通函数）

在下述代码中，普通函数的形参定义的也为int型，实参为int时，这里的swapAll()函数则选择调用普通函数

这里让编译器根据实参推演模板参数的实际类型 称为 隐式实例化

template<typename T>
void swapAll(T &a,T &b) //函数模板
{
   
	T tmp = a;
	a = b;
	b = tmp;
}

void swapAll(int& a, int& b)//普通函数 
{
   
	int tmp = a;
	a = b;
	b = tmp;
}

int main()
{
   
	int a = 10, b = 20;
	swapAll(a, b);//调用普通函数

	return 0;
}

当函数模板 与 普通函数同时出现时，我们想要强制调用函数模板时

这里 在函数名后的<>中指定模板参数的实际类型 称为 显示实例化

int main()
{
   
	int a = 10, b = 20;
	swapAll<>(a, b); //调用函数模板 只需要加入尖括号即可

	return 0;
}

补充：模板支持多个模板参数

int main()
{
   
	swapAll<int,char>(1,'A');
}

参数匹配调用函数模板 或 普通函数

函数模板不允许自动类型转换，但是普通函数却可以进行自动类型转换

假设有如下代码：

#include<math.h>
#include<iostream>
using namespace std;

template<typename T>
void printAll(T a,T b) //函数模板
{
   
	cout << a << " " << b << endl;
	cout << "函数模板" << endl;
}

void printAll(int a, int b)//普通函数 
{
   
	cout << a << " " << b << endl;
	cout << "普通函数" << endl;
}

int main()
{
   
	printAll(10, 20); //普通函数
	printAll('a', 'b');//函数模板
	printAll(10, 'a');//普通函数

	return 0;
}

在主函数中，调用printAll(10, 'a'); 第一个实参是int类型，如果是函数模板，第二个类型应也为int，但是函数模板不支持自动类型转换，所以‘a’ 不可转化为int。则这里的调用应该调用的是普通函数，将‘a’ 转化为int

但是如果强制说明T为int类型，就支持自动类型转化

printAll<int>(10,'a');

函数模板的重载

template<typename T>
void printAll(T a,T b) //函数模板
{
   
	cout << a << " " << b << endl;
	cout << "函数模板" << endl;
}

template<typename T>
void printAll(T a) //函数模板
{
   
	cout << a << endl;
	cout << "函数模板" << endl;
}

局限性

当函数模板推导出 T 为数组 或其他自定义类型数据，可能会导致运算符不识别

解决1：运算符重载

一般运算符重载的的函数形式如下

<返回类型说明符> operator <运算符符号>(<参数表>)
{
   
	<函数体>
}

一些规则：
1.C++规定重载后的运算符操作对象必须是少有一个是用户定义的类型
2.使用运算符不能违法运算符原来的句法规则
3.不能修改运算符原先的优先级
4.不能创建一个新的运算符，例如不能定义operator**来求幂
5.一些不能重载的运算符：成员运算符、作用域运算符、条件运算符、sizeof运算符、typeid运算符、const_cast、dynamic_cast、reinterpret_cast、static_cast强制类型转换运算符
6.大多数运算符可以通过成员函数和非成员函数进行重载：但是=、（）、[]、->只能通过成员函数进行重载

#include