20240425，模板

感觉比学C那会好了点，不怎么出现照着抄但是就是不能跑的情况，哭死，但是学的顺又不复习，第二天跟没学一样，笑死，要是能给我开个过目不忘的挂，爽的不要不要的
呵呵呵蠢女人，别忘了你C++的作业没做，C的坑还没补

目录

模板

0.1 函数模板

开局BUG：提示对重载函数的调用不明确，是一开始图简单，三个函数名写成了 SWAPINT , SWAPDOUBLE , 模板函数是SWAP改成SWAP(A,B)没用，模板函数名改成MYSWAP报错消失​编辑

 正确

0.1.1 注意事项

0.1.2 函数模板案例——数组排序

 0.1.3 普通函数和函数模板的区别

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

0.1.5 模板局限性

模板

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

0.1 函数模板

作用：建立一个通用函数，其函数返回值类型和形参类型可以不具体制定，用一个虚拟的类型来代表
语法：template < typename T>，函数声明或定义
template--声明创建模板；typename--表明其后面的符号是一种数据类型，可以用CLASS代替；T--通用的数据类型，名称可以替换，通常为大写字母

开局BUG：提示对重载函数的调用不明确，是一开始图简单，三个函数名写成了 SWAPINT , SWAPDOUBLE , 模板函数是SWAP
改成SWAP(A,B)没用，模板函数名改成MYSWAP报错消失

#include<iostream>
using namespace std;
void swapint(int& a, int& b) {
	int temp = a;
	a = b;
	b = temp;
}
void swapdouble(double& a, double& b) {
	double temp = a;
	a = b;
	b = temp;
}
//声明一个模板，告诉编译器后面代码中紧跟着的T不要报错，T是一个通用的数据类型
template <typename T>
void swap(T &a, T &b) {
	T t= a;
	a = b;
	b = t;
}
void test01() {
	int a = 10; int b = 30;
	swapint(a, b);
	cout << a << "\t" << b << endl;
	double c = 4.333; double d = 231.21;
	swapdouble(c, d);
	cout << c << "\t" << d << endl;
 
	swap(a, b);
	cout << a << "\t" << b << endl;
}
int main()
{
	test01();
	system("pause");
	return 0;
}

 正确

#include<iostream>
using namespace std;
void swapint(int& a, int& b) {
	int temp = a;
	a = b;
	b = temp;
}
void swapdouble(double& a, double& b) {
	double temp = a;
	a = b;
	b = temp;
}
//声明一个模板，告诉编译器后面代码中紧跟着的T不要报错，T是一个通用的数据类型
template <typename T>
void myswap(T &a, T &b) {
	T t= a;
	a = b;
	b = t;
}
void test01() {
	int a = 10; int b = 30;
	swapint(a, b);
	cout << a << "\t" << b << endl;
	double c = 4.333; double d = 231.21;
	swapdouble(c, d);
	cout << c << "\t" << d << endl;
	//自动类型推导
	myswap(a, b);
	cout << a << "\t" << b << endl;
	myswap(c, d);
	cout << c << "\t" << d << endl;
	//显示指定类型
	myswap<int>(a, b);
	cout << a << "\t" << b << endl;
	myswap<double>(c, d);
	cout << c << "\t" << d << endl;
}
int main()
{
	test01();
	system("pause");
	return 0;
}

0.1.1 注意事项

 自动类型推导，必须推导出一致的数据类型才可以使用
模板必须要确定出T的数据类型，才可以使用（可以不调用T，但是要确定类型）

#include<iostream>
using namespace std;
 
template<class T>
void myswap(T& a, T& b) {
	T temp = a;
	a = b;
	b = temp;
}
template<class T>
void func() {
	cout << "function 的函数调用" << endl;
}
void test01() {
	int a = 0; int b = 77;
	double c = 43.23;
	char d = 'c';
	myswap(a, b);
	cout << a << "\t" << b << endl;
	//myswap(a, c);错误
	//func();错误
	func<int>();
	func<double>();
	func<string>();
	func<char>();
}
int main()
{
	test01();
	system("pause");
	return 0;
}

0.1.2 函数模板案例——数组排序

从大到小，排序算法为选择排序，测试CHAR数组，INT数组
函数模板使用调用数组参数时，限定的是数组的单元的数据类型……反正就那意思

#include<iostream>
using namespace std;
 
template<class T>
void func(T arr[], int len) {//只是用T代替不确定的数据类型，嗯，是不确定的
	for (int i = 0; i < len; i++) {
		int max=i;
		for (int j = i+1; j < len; j++) {
			if (arr[max] < arr[j]) {
				max = j;
			}
		}
		//arr[i] = max;交换，不是简单的赋值，乐
		if (i!= max) {
			T temp = arr[i];
			arr[i] = arr[max];
			arr[max] = temp;
		}
	}
}
void test01() {
	char chararr[] = { "fwsfgwegeh" };
	int intarr[] = { 2,43,4,5,3,55,2, };
	int lenchar = sizeof(chararr) / sizeof(chararr[0]);
	int lenint = sizeof(intarr) / sizeof(intarr[0]);
	cout << lenchar << " " << lenint << endl;
	for (int i = 0; i < lenchar; i++) {
		cout << chararr[i] << " ";
	}
	cout << endl;
	for (int i = 0; i < lenint; i++) {
		cout << intarr[i] << " ";
	}
	cout << endl;
	func(chararr, lenchar);
	for (int i = 0; i < lenchar; i++) {
		cout << chararr[i] << " ";
	}
	cout << endl;
	func(intarr, lenint);
	for (int i = 0; i < lenint; i++) {
		cout << intarr[i] << " ";
	}
	cout << endl;
}
int main()
{
	test01();
	system("pause");
	return 0;
}

 0.1.3 普通函数和函数模板的区别

普通函数调用时可以发生自动类型转（隐式类型转换）
函数模板调用时，如果利用自动类型推导，不会发生隐式类型转换
如果利用显示指定类型的方式，可以发生隐式类型转换
补：敲代码发现，引用方式接收参数的，都不会发生，暂时时这样的……

#include<iostream>
using namespace std;
 
int func(int a,int b) {
	return a + b;
}
template <class T>
T myadd(T& a, T& b) {
	return a + b;
}
template <class T>
T hhmyadd(T a, T b) {
	return a + b;
}
void test01() {
	int a = 10; int b = 50;
	char c = 'a';
	cout << func(a, b) << endl;
	cout << func(a, c) << endl;//c强制转换成了INT型ACSII码
	cout << myadd(a, b) << endl;
	//cout << myadd(a, c) << endl;//自动类型推导，不行
	//cout << myadd<int>(a, c) << endl;//显示不行
	cout << hhmyadd<int>(a, c) << endl;//显示，可以
}
int main()
{
	test01();
	system("pause");
	return 0;
}

 建议使用显示指定类型的方式

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

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

#include<iostream>
using namespace std;
 
void func(int a,int b) {
	cout << "调用 普通 函数" << endl;
}//如果只给声明，还是调用普通，但是报错
void func(int a, int b,int c) {
	cout << "调用 普通chongzai 函数" << endl;
}
 
template <class T>
void func(T a, T b) {
	cout << "调用 模板" << endl;
}
template <class T>
void func(T a, T b,T c) {
	cout << "调用 重载 模板" << endl;
}
void test01() {
	int a = 10; int b = 50;
	int c = 899;
	func(a, b);
	func<>(a,b);//通过 空模板参数列表 来强制调用函数模板
	func(a, b, c);
	char c1 = 'a'; char c2 = 'c'; char c3 = 'r';
	func(c1, c2, c3);//如果函数模板可以产生更好的匹配，优先调用函数模板
	func(a, b, c1);
}
int main()
{
	test01();
	system("pause");
	return 0;
}

0.1.5 模板局限性

 传入数组-赋值操作，传入类--比较操作；无法正常运行
解决：模板的重载，可以为特定的（自定义）类型提供具体化的模板；运算符重载【感觉差不多，乐】
学习模板不是为了写模板，是为了在STL能够运用系统提供的模板

#include<iostream>
#include<string>
using namespace std;
class Person {
public:
	string m_name;
	int m_age;
	Person(string name,int age) {
		m_name = name;
		m_age = age;
	}
};
template<class T>
bool mycompare(T& a, T& b) {
	if (a == b) {
		return true;
	}
	else {
		return false;
	}
}
//为特定的类型提供具体化的模板
template<> bool mycompare(Person& a, Person& b) {
	if (a.m_name == b.m_name && a.m_age == b.m_age) {
		return true;
	}
	else {
		return false;
	}
}
void test01() {
	int a = 9; int b = 9;
	if (mycompare(a, b)) {
		cout << "xiangdeng" << endl;
	}
	else {
		cout << " bu bu bu " << endl;
	}
}
void test02() {
	Person a("张三",12);
	Person b("张三", 12);
	if (mycompare(a, b)) {
		cout << "xiangdeng" << endl;
	}
	else {
		cout << " bu bu bu " << endl;
	}
}
int main()
{
	test01();
	test02();
	system("pause");
	return 0;
}