C++泛型编程:函数模板

基本语法：

template 
void mySwap(T& a, T& b)
{//类型参数化
	T temp = a;
	a = b;
	b = temp;
}
void test01()
{
	int a = 10, b = 20;
	//自动类型推导
	mySwap(a,b);
	//显示指定类型
	mySwap(a, b);
}

实例：数组排序

template
void mySort(T arr[], int len)
{
	cout << len << endl;
	for (int i = 0; i < len-1; 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 
void PrintArr(T arr[], int len)
{
	for (int i = 0; i < len; i++)cout << arr[i] << " ";
	cout << endl;
}
void test02()
{
	char charArr[] = "badcef";
	int num = sizeof(charArr)/ sizeof(char);
	num -= 1;//消除'\0'的影响
	mySort(charArr, num);
	PrintArr(charArr, num);
	int intArr[] = { 0,2,1,3,4,5 };
	num = sizeof(intArr) / sizeof(int);
	mySort(intArr, num);
	PrintArr(intArr, num);
}

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

普通函数可以发生隐式类型转换，而对于函数模板，自动类型转换不可以发生隐式类型转换
，显示指定类型可以发生隐式类型转换。

template
T myAdd(T a, T b)
{
	return a + b;
}
void test03()
{
	int a = 10;
	char c = 'c';
	cout << myAdd(a, c) << endl;
}

普通函数与函数模板的调用规则：

//如果函数模板和普通函数都可以调用，优先调用普通函数

//通过空模板的参数列表，强制调用函数模板

//如果函数模板产生更好的匹配，优先调用函数模板

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

template
void myPrint(T a, T b,T c)
{
	cout << "调用重载的函数模板" << endl;
}
void test04()
{
	int a = 10, b = 20;
	//如果函数模板和普通函数都可以调用，优先调用普通函数
	myPrint(a, b);
	//通过空模板的参数列表，强制调用函数模板
	myPrint<>(a, b);
	myPrint<>(a, b, 1);
	//如果函数模板产生更好的匹配，优先调用函数模板
	char c1 = 'c', c2 = 'a';
	myPrint(c1, c2);
}

模板的局限性：

class Person
{
public:
	Person(string name,int age)
	{
		m_Name = name;
		m_age = age;
	}
	string m_Name;
	int m_age;
};
template
bool myComp(T& a, T& b)
{
	if (a == b)return true;
	else return false;
}
template<> bool myComp(Person& a, Person& b)
{
	if (a.m_age == b.m_age && a.m_Name == b.m_Name)return true;
	else return false;
}
void test05()
{
	Person p1("Tom", 10); Person p2("Tom", 10);
	bool ret = myComp(p1, p2);
	if (ret)
	{
		cout << "p1==p2" << endl;
	}
	else cout << "P1!=p2" << endl;
}