c++函数模板

1.1模板的概念

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

模板的特点：

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

• C++另一种编程思想称为 泛型编程 ，主要利用的技术就是模板

• C++提供两种模板机制:函数模板和类模板

函数模板语法：

template<typename T>  其中typename可用class替换，
函数声明及定义  

解释：

template — 声明创建模板

typename — 表面其后面的符号是一种数据类型，可以用class代替

T — 通用的数据类型，名称可以替换，通常为大写字母

1.2

//交换整型函数
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;
}

通过上面两端代码可以看出，除了数据类型不一样，其他的框架一模一样，这样就可以使用模板来缩小代码量。

//利用模板提供通用的交换函数
template<typename T>
void mySwap(T& a, T& b)
{
	T temp = a;
	a = b;
	b = temp;
}

1.3 

模板的调用

void test01()
{
	int a = 10;
	int b = 20;
	
	//利用模板实现交换
	//1、自动类型推导
	mySwap(a, b);

	//2、显示指定类型
	mySwap<int>(a, b);
}

1.4.函数模板注意点

1.4.1  自动类型推导，必须推导出一致的数据类型T,才可以使用。

（细讲：编译器进行完自动类型推导之后会以程序员写的函数模板生成一个类型确定的函数，这个过程叫做函数模板的实例化，该类型确定的函数成为函数模板的一个实例，所以我们调用的相当于是这个实例化的函数。）

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

	mySwap(a, b); // 正确，可以推导出一致的T
	//mySwap(a, c); // 错误，推导不出一致的T类型
}

1.4.2

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

void test02()
{
	//func(); //错误，模板不能独立使用，必须确定出T的类型，或者在上面的函数参数列表里面加一个帮助判断的参数，例如T a;下面调用的时候直接传指定类型的数据。
	func<int>(); //利用显示指定类型的方式，给T一个类型，才可以使用该模板

}

 

1.5实际案例

字符串数组和数字数组排序。二者共用一套函数模板

#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 print_array(T arr[], int len) {
	for (int i = 0; i < len; i++)
		cout << arr[i] << " ";
}
//排序模板
template<class T>
void arrange(T arr[], int len) {
	for (int i = 0; i < len; i++) {
		for (int j = 0; j < len; j++) {
			if (arr[j] < arr[j + 1])
				myswap(arr[j], arr[j + 1]);
		}
	}
	print_array(arr, 10);
}

int main() {
	int arr[10] = { 1,2,5,9,7,6,3,8,4,9 };
	int len = sizeof(arr) / sizeof(arr[0]);
	arrange(arr, len);
	cout << endl;
	char arr1[10] = { 'b','d','c','r','t','q','g','w','s','v' };
	int len1 = sizeof(arr) / sizeof(arr[0]);
	arrange(arr1, len1);
}

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

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

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

示例：

//普通函数
int myAdd01(int a, int b)
{
	return a + b;
}

//函数模板
template<class T>
T myAdd02(T a, T b)  
{
	return a + b;
}

//使用函数模板时，如果用自动类型推导，不会发生自动类型转换,即隐式类型转换
void test01()
{
	int a = 10;
	int b = 20;
	char c = 'c';
	
	cout << myAdd01(a, c) << endl; //正确，将char类型的'c'隐式转换为int类型  'c' 对应 ASCII码 99

	//myAdd02(a, c); // 报错，使用自动类型推导时，不会发生隐式类型转换

	myAdd02<int>(a, c); //正确，如果用显示指定类型，可以发生隐式类型转换
}

int main() {

	test01();

	system("pause");

	return 0;
}

•  

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

1.7模板局限性

 

1.7.1局限性：

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

例如：在代码中提供的赋值操作，如果传入的a和b是一个数组，就无法实现了

	template<class T>
	void f(T a, T b)
	{ 
    	a = b;
    }

 

 

1.7.2 解决办法

再例如：如果T的数据类型传入的是像Person这样的自定义数据类型，也无法正常运行

	template<class T>
	void f(T a, T b)
	{ 
    	if(a > b) { ... }
    }

 

解决办法：1.我们之前学过的运算符重载

                  2.对模板进行重载，提供具体化的模板。

#include<iostream>
#include<string>
using namespace std;
class person {
public:
	person(string n, string a) :name(n), age(a){}
	string name;
	string age;
};
//通用模板，内置数据类型可以直接使用通用的函数模板
template<class T>
bool fun(T&a,T&b) {
	if (a == b) return right;
	else return false;
}

//自定义数据类型，不会调用普通的函数模板
//可以创建具体化的Person数据类型的模板，用于特殊处理这个类型
//具体化，显示具体化的原型和定意思以template<>开头
//具体化优先于常规模板
template<> bool fun(person& p1, person& p2) {
	if (p1.age == p2.age && p1.name == p2.name) 
		return right;
	else 
		return false;
}
int main() {
	person p1("张强", "20");
	person p2("张强", "19");
	if (fun(p1, p2) == 1) cout << "相等" << endl;
	else cout << "不相等" << endl;
}

 

 

 

几个需要注意的点：

1.被多个源文件（cpp）引用的函数模板，必须将声明和实现一起放到头文件中，而不能分开写。

2.函数指针只能指向模板的示例，而不能指向模板本身。

3.函数模板本身在编译的时候不会产生任何目标代码，只有由模板生成的实例会生成目标代码。