2022-07-07

C++之泛型编程（2）
案例描述：
1.利用函数模板封装排序函数，实现对不同数据类型数组排序
2.选择排序，按照从大到小
3.int和char数组进行测试
example：

#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 mySort(T arr[],int len) 
{
	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;

			}

		}
		if (max!=i)
		{
			mySwap(arr[max],arr[i]);

		}

	}

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

	}
}

void test()
{
	char charArr[] = "degfack";
	int intNum[] = {2,5,7,9,6,3};
	cout << "排序之前的结果为：" << endl;
	int num1 = sizeof(charArr) / sizeof(char);
	int num2= sizeof(intNum) / sizeof(int);
	myPrint(charArr, num1);
	myPrint(intNum, num2);
	mySort<char>(charArr, num1);
	mySort<int>(intNum,num2);
	cout << "排序之后的结果为：" << endl;
	myPrint(charArr, num1);
	myPrint(intNum, num2);
	
}
int main() 
{
	test();
	system("pause");
	return 0;

}

2.普通函数与模板函数区别
2.1普通函数调用可以发生自动类型转换
2.2函数模板调用时，如果利用自动类型推导，不会发生隐式类型转换
2.3如果是显式指定，同普通函数类似。会发生隐式类型转换
example：

#include<iostream>
using namespace std;

int Add1(int a, int b) 
{
	return a + b;
}

template<class T>
int Add(T a, T b)
{
	return a + b;
}
void test() 
{
	int a = 10;
	int b = 20;
	char c = 'c';
	Add<int>(a, b);
	cout<<"普通函数发生隐式转换："<<endl;
	Add1(a, c);
	cout << "a+c= " << Add1(a, c) << endl;
	cout << "模板函数发生隐式转换：" << endl;
	Add<int>(a, c);//显示指定
	cout << "a+c= " << Add<int>(a, c) << endl;
}
int main() 
{

	test();
	system("pause");
	return 0;
}

模板函数需要显示指定类型，可以使函数发生隐式类型转换

Add<int>(a, c);

3.调用规则之普通函数与模板函数
3.1 两者都可以实现，先调用普通函数
3.2 空模板函数列表来强制调用模板函数
3.3 函数模板也可以发生重载
3.4 如果函数模板可以产生更好的匹配，优先调用函数模板
example:

#include<iostream>

using namespace std;

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

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

void test()
{
	int a = 10, b = 10;
    Func(a,b);
}

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

优先调用普通函数

将Func（a,b）
改为

Func<>(a,b)

实现空模板函数列表来强制调用模板函数

3.3重载与更好的匹配
模板函数的重载类似于普通函数的重载
当函数模板可以产生更好的匹配，优先调用函数模板
如以下案例

#include<iostream>
//Ctrl+k+c 多行注释
//Ctrl+K+U 取消多行注释

using namespace std;

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 Func(int a, int b)
{
	cout << "调用普通函数：：" << endl;
}

void test()
{
	int a = 10, b = 10;
    //Func<>(a,b);
	Func<>(a, b,100);
	char c = 'c', d = 'd';
	Func(c, d);


}

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

在上述中c,d 属于char类型，普通函数用于int类型，所以此处函数模板适用度更好，所以调用了函数模板

3.4局限性
1…如果为自定义的数据类型，也无法正常运行
2.赋值操作中，如果是数据，可以直接使用模板函数，如果是数组，没法使用
example

#include<iostream>
#include<string>
//Ctrl+k+c 多行注释
//Ctrl+K+U 取消多行注释

using namespace std;
class Person 
{
public:
	Person(int age, string name) 
	{
		this->m_age = age;
		this->m_name = name;
	}
	int m_age;
	string m_name;
};
template<class T>
bool myCompare(T &a, T &b) 
{
	if (a == b)
	{
		return true;
	}
	else
		return false;
}
template <> bool myCompare(Person &p1, Person &p2)
{
	if (p1.m_age = p2.m_age && p1.m_name == p2.m_name)
	{	
		return true;
	}
	else
		return false;
}

void test()
{
	int a = 10; int b = 10;
	bool ret1 = myCompare(a, b);
	if (ret1)
	{
		cout << "相同" << endl;
	}
	else
		cout << "不相同" << endl;

	Person p1(10,"Tom");
	Person p2(10, "Jerry");
	bool ret=myCompare(p1, p2);
	if (ret)
	{
		cout << "相同" << endl;
	}
	else 
		cout << "不相同" << endl;

}

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

1.具体化的自定义数据类型，用于特殊处理该类型

2.对运算符号==进行重置操作，但是该方法只解决了单一的问题，如果存在别的运算符，仍然需要重置操作