[C++提高编程]（一）：模板----函数模板

目录

函数模板作用

函数模板的语法

注意事项

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

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

模板的局限性

案例--通用数组选择排序从大到小

---

模板是C++中泛型编程的基础，一个模板就是一个创建类或函数的蓝图或者公式。

函数模板作用

建立一个通用函数，其函数返回值类型和形参类型可不具体制定，用一个虚拟类型来代表.

函数模板的语法

        template<typename T>

        函数声明或定义

注意事项

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

#include <iostream>
using namespace std;

template<typename T>//typename可以替换成class
void swapType(T& a, T& b)
{
	T temp = a;
	a = b;
	b = temp;
}

template<typename T> //未确认T数据类型，无法使用自动类型推导调用
void func()
{
    cout << "func 调用" << endl;
}

static void test01()
{
	int a = 10, b = 20;
	cout << "交换前：a,b=" << a << "," << b << endl;
	swapType<int>(a, b);  //显示指定类型
	cout << "交换后：a,b=" << a << "," << b << endl;

	double x = 11.1, m = 22.2;
	cout << "交换前：x,m=" << x << "," << m << endl;
	swapType(x, m);       //自动类型推导
	cout << "交换后：x,m=" << x << "," << m << endl;

}

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

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

• 普通函数可以发送隐式类型转换
• 函数模板 用自动类型推导，不可以发生隐式类型转换
• 函数模板 用显示指定类型，可以发生隐式类型转换

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

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

        注意：使用函数模板后就不要再使用普通函数，容易产生二义性

#include <iostream>
using namespace std;


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

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

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

void test()
{
	int a = 4, b = 1;
	myPrint(a, b);   //优先调用普通函数

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

	myPrint(a, b, 3); //空模板列表强制调用函数模板

	myPrint('a', 'b'); //更好的匹配调用函数模板
}


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

模板的局限性

        模板虽然通用但不是万能的

        利用重载，针对特定化类型提供具体化的模板

#include <iostream>
using namespace std;

class Person
{
public:
	string m_name;
	int m_age;

	Person(string name, int age)
	{
		this->m_name = name;
		this->m_age = age;
	}
};

template<class T> 
bool myCompare(T &a, T &b)
{
	if (a == b)
	{
		cout << "相等" << endl;
		return true;
	}
	else
	{
		cout << "不相等" << endl;
		return false;
	}
}

//利用重载，针对特定化类型提供具体化的模板
template<> bool myCompare(Person& p1, Person& p2) 
{
	if (p1.m_name == p2.m_name && p1.m_age == p2.m_age)
	{
		cout << "相等" << endl;
		return true;
	}
	else
	{
		cout << "不相等" << endl;
		return false;
	}
}

static void test()
{
	bool result = 0;

	int a = 4, b = 1;
	result = myCompare(a, b);  

	Person p1("Tom", 10);
	Person p2("Tom", 10);
	result = myCompare(p1, p2); 
}


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

案例--通用类型数组-选择排序-从大到小

#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 printArray(T arr[], int len)
{
	for (int i = 0; i < len; i++)
	{
		cout << arr[i];
	}
	cout << endl;
}

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]);
		}
	}
}

static void test01char()
{
	char charArr[] = "febadc";
	int num = sizeof(charArr) / sizeof(char);
	mySort(charArr, num);
	printArray(charArr, num);

}

static void test02int()
{
	int charArr[] = {3,1,9,4,5,7,8};
	int num = sizeof(charArr) / sizeof(int);
	mySort(charArr, num);
	printArray(charArr, num);

}

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