【C++】学习笔记[十四]

模板

一、模板的概念

模板就是建立通用的模具，大大提高复用性。

模板的特点：

• 模板不可以直接使用，它只是一个框架
• 模板的通用并不是万能的

C++的另一种编程思想称为泛型编程，主要利用的技术就是模板
C++提供两种模板机制称为函数模板和类模板

二、函数模板

函数模板基本概念

函数模板的作用：建立一个通用函数，其函数返回值类型和形参类型可以不用具体制定，用一个虚拟的类型来代表。

语法：
template<typename T> 函数声明成定义

其中typename可以用class来代替。

案例练习：

#include <iostream>
using namespace std;

//函数模板
template<typename T>//声明一个模板，告诉编译器后面代码T不要报错
void mySwap(T& a, T& b)
{
	T tmp = a;
	a = b;
	b = tmp;
}

void test01()
{
	int a = 10;
	int b = 20;
	//利用函数模板实现两个变量的交换
	//有两种方式使用函数模板
	//第一种：自动类型推到
	//mySwap(a, b);

	//第二种：显示指定类型
	mySwap<int>(a, b);

	cout << "a:" << a << endl;
	cout << "b:" << b << endl;
}

int main()
{
	test01();
	system("pause");
	return 0;
}

总结：

• 函数模板利用关键字template
• 使用函数模板有两种方式：自动类型推导和显示指定类型
• 模板的目的是为了提高复用性，将类型参数化

函数模板注意事项

注意事项：

• 自动类型推导，必须推导出一致的数据类型T，才可以使用
• 模板必须要确定出T的数据类型，才可以使用

练习：

#include <iostream>
using namespace std;

//函数模板注意事项

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


//1、自动类型推导必须推导出一致的类型才可使用
void test01()
{

	int a = 10;
	int b = 20;

	char c = 'c';

	mySwap(a, b);//true
	//mySwap(a, c);//error,推导不出一致的T类型

	cout << "a:" << a << endl;
	cout << "b:" << b << endl;

}

//2、模板必须确定T的数据类型，才可以使用
template<typename T>
void func()
{
	cout << "func run" << endl;
}

void test02()
{
	//func();//error
	func<int>();//true
}

int main()
{
	test01();
	test02();
	system("pause");
	return 0;
}

总结：

• 使用模板时必须确定出通用数据类型T，并且能够推导出一致的数据类型

函数模板案例

案例描述：

• 利用函数模板封装一个排序的函数，可以对不同数据类型的数组进行排序
• 排序规则从大到小，排序算法为选择排序
• 分别利用char数组和int数组进行测试

案例代码：

#include <iostream>
using namespace std;

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

template<typename T>
void PrintArray(T arr[], int len)
{
	for (int i = 0; i < len; i++)
	{
		cout << arr[i] << " " ;
	}
	cout << endl;
}

template<typename T>
void mySort(T arr[], int len)
{
	for (int i = 0; i < len; i++)
	{
		int maxindex = i;
		for (int j = i + 1; j < len; j++)
		{
			if (arr[maxindex] < arr[j])
			{
				maxindex = j;
			}
		}
		if (maxindex != i)
		{
			mySwap(arr[maxindex], arr[i]);
		}
	}
}

void test01()
{
	//测试char数组
	char charArr[] = "bacdef";
	int len = sizeof(charArr) / sizeof(charArr[0]);
	mySort(charArr, len);

	PrintArray(charArr, len);
}

void test02()
{
	int intArr[] = { 2,4,1,3,6,5 };
	int len = sizeof(intArr) / sizeof(intArr[0]);

	mySort(intArr, len);

	PrintArray(intArr,len);
}

int main()
{
	test01();
	test02();
	system("pause");
	return 0;
}

普通函数与函数模板的区别

区别如下：

• 普通函数调用时可以发生自动类型转换（隐式转换）
• 函数模板调用时，如果利用自动类型推导，不会发生隐式类型转换
• 如果利用显示指定类型的方式，可以发生隐式类型转换

练习代码：

#include <iostream>
using namespace std;

//普通函数与函数模板的区别
//1、普通函数调用可以发生隐式类型转换
int myAdd(int a, int b)
{
	return a + b;
}
void test01()
{
	int a = 10;
	int b = 20;

	char c = 'c';//将字符型转成了整型（发生了隐式转换）

	cout << myAdd(a, b) << endl;
	cout << myAdd(a, c) << endl;//10+99=109
}


//2、函数模板用自动类型推导，不可以发生隐式类型转换

template<typename T>
T myAdd02(T a, T b)
{
	return a + b;
}

void test02()
{
	int a = 10;
	int b = 20;
	char c = 'c';

	cout << myAdd02(a, b) << endl;//30
	//cout << myAdd02(a, c) << endl;//error 不可以发生隐式类型转换

	//3、函数模板用显示指定类型，可以发生隐式类型转换
	cout << myAdd02<int>(a,c) << endl;
}


int main()
{
	test02();
	system("pause");
	return 0;
}

建议使用显示指定类型的方式调用函数模板，因为可以自己确定通用类型T。

普通函数和函数模板的调用规则

规则如下：

• 如果函数模板和普通函数都可以实现，优先调用普通函数
• 可以通过空模板参数列表来强制调用函数模板
• 函数模板也可以发生重载
• 如果函数模板可以产生更好的匹配，优先调用函数模板

练习代码：

#include <iostream>
using namespace std;

//普通函数和函数模板的调用规则
//1、如果函数模板和普通函数都可以调用，优先调用普通函数
//2、可以通过空模板参数列表的方式强制调用函数模板
//3、函数模板也可以发生函数重载
//4、如果函数模板可以产生更好的匹配，优先调用函数模板

void myPrint(int a, int b)
{
	cout << "调用普通函数" << endl;
}

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

template<typename T>
void myPrint(T a, T b,T c)
{
	cout << "调用重载函数模板" << endl;
}

void test01()
{
	int a = 10;
	int b = 20;

	//如果函数模板产生更好的匹配，优先调用函数模板
	char c1 = 'a';
	char c2 = 'b';
	myPrint(c1, c2);//调用函数模板，因为普通函数需要进行隐式类型转换
	

	//myPrint(a, b, 100);//函数模板也可以发生重载


	//myPrint(a, b);//函数模板和普通函数都可以调用优先调用普通函数
	要是普通函数只有声明没有实现会报错

	通过空模板参数列表强制调用函数模板
	//myPrint<>(a, b);


}

int main()
{
	test01();

	system("pause");
	return 0;
}

建议在实际开发中，如果已经提供了函数模板，就最好不要提供普通函数，否则容易出现二义性。

模板的局限性

• 模板的通用性并不是万能的

举个例子如下：

#include <iostream>
#include <string>
using namespace std;

//模板的局限性
//有些特定的数据类型，需要用具体化的方式做特殊实现

class Person
{
public:
	Person(int age, string name)
	{
		m_age = age;
		m_name = name;
	}

	int m_age;
	string m_name;
};

//对比两个数据是否相等的函数
template<typename T>
bool myCompare(T& a, T& b)
{
	if (a == b)
	{
		return true;
	}
	else
	{
		return false;
	}
}

//利用具体化的Person的版本来实现比较代码，具体化会优先调用
template<> bool myCompare(Person& a, Person& b)
{
	if (a.m_age == b.m_age && a.m_name == b.m_name)
	{
		return true;
	}
	else
	{
		return false;
	}
}

void test01()
{
	int a = 10;
	int b = 20;

	bool ret = myCompare(a, b);

	if (ret)
	{
		cout << "a==b" << endl;
	}
	else
	{
		cout << "a!=b" << endl;
	}
}


//要是没有Person的具体化处理，调用该测试函数会报错
void test02()
{
	Person p1(13, "Tom");
	Person p2(12, "Tom");

	bool ret = myCompare(p1, p2);
	if (ret)
	{
		cout << "p1==p2" << endl;
	}
	else
	{
		cout << "p1!=p2" << endl;
	}
}

int main()
{
	test01();
	test02();
	system("pause");
	return 0;
}

总结：利用具体化的模板，可以解决自定义类型的通用化。

函数模板介绍到这里就结束了，类模板见下篇笔记💖💖

👏👏👏
fighting！！！