C++基础——函数模板

泛型编程

模板体现了泛型编程，泛型编程是编写与类型无关的通用代码，是代码复用的一种手段。模板是泛型编程的基础。

在学习泛型编程之前，我们回忆一下怎么实现两个整形，浮点型，字符型的数据交换。

void Swap(int& left, int& right)
{
	int temp = left;
	left = right;
	right = temp;
}

void Swap(double& left, double& right)
{
	double temp = left;
	left = right;
	right = temp;
}

void Swap(char& left, char& right)
{
	char temp = left;
	left = right;
	right = temp;
}

使用函数重载虽然可以实现，但是有几个不好的地方：

1. 重载的函数仅仅是类型不同，代码复用率比较低，只要有新类型出现时，就需要用户自己增加对应的函数
2. 代码的可维护性比较低，一个出错可能所有的重载均出错

因此，C++为了更好的处理这种问题，达到泛型编程的目的，引入了一个概念---模板；

一、函数模板

1.函数模板语法

函数模板作用： 建立一个通用函数，其函数返回值类型和形参类型可以不具体制定，用一个虚拟的类型来代表。

template<typename T>
函数声明或定义

解释：

        template --- 声明创建模板

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

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

注意：typename是用来定义模板参数关键字，也可以使用class(切记：不能使用struct代替class)

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

使用方法：

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

	//1.自动类型推导
	//myswap(a, b);

	//2.显示指定类型
	myswap<int>(a, b);
	cout << "a = " << a << endl;
	cout << "b = " << b << endl;
}

总结：

• 函数模板利用关键字template
• 使用函数模板有两种方式：自动类型推导、显示指定类型
• 模板的目的是为了提高复用性，将类型参数化

2.注意事项

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

#include<iostream>
using namespace std;
template<class T>
void mySwap(T& a, T& b)
{
	T c = a;
	a = b;
	b = c;
}
void test01()
{
	int a = 10;
	int b = 20;
	char c = 'c';
	//1.自动类型推导必须推导出一致的数据类型T才可以使用
	//mySwap(a, c);
	mySwap(a, b);

	cout << "a = " << a << endl;
	cout << "b = " << b << endl;
	cout << "c = " << c << endl;

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

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

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

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

#include<iostream>
using namespace std;

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

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

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

4.普通函数与函数模板的调用区别

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

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

#include<iostream>
using namespace std;

void myPrint(int a, int b)//优先
{
    cout << "putonghanshu" << endl;
}

template<class T>
void myPrint(T a, T b)
{
    cout << "moban" << endl;
}

//3.函数模板也可以发生重载
template<class T>
void myPrint(T a, T b, T c)
{
    cout << "mobanchongzai" << endl;
}

void test01()
{
    //1.函数模板和普通函数都可以实现，优先调用普通函数
    int a = 30, b = 20;
    myPrint(a, b);

    //2.可以通过空模板参数列表来强制调用函数模板
    myPrint<>(a, b);

    //3.函数模板也可以发生重载
    myPrint(a, b, 100);

    //4.如果函数模板可以更好的匹配，优先调用函数模板
    char c1 = 'a';
    char c2 = 'b';
    myPrint(c1, c2);
}
int main()
{
    test01();
    return 0;
}

既然提供了函数模板，最好就不要提供普通函数，否则容易出现二义性。

5.函数模板的原理

函数模板是一个蓝图，它本身并不是函数，是编译器用使用方式产生特定具体类型函数的模具。所以其实模板就是将本来应该我们做的重复的事情交给了编译器。

在编译器编译阶段，对于模板函数的使用，编译器需要根据传入的实参类型来推演生成对应类型的函数以供调用。比如：当用double类型使用函数模板时，编译器通过对实参类型的推演，将T确定为double类型，然后产生一份专门处理double类型的代码，对于字符类型也是如此。

6.模板的局限性

模板的通用性并不是万能的，如果传入的变量a和b是一个数组，就无法实现了；如果T的数据类型传入的是像Person那样的自定义数据类型，也无法正常运行。

为了解决这种问题，提供模板的重载，可以为这些特定的类型提供具体化的模板；

#include<iostream>
using namespace std;
//对比俩个数据是否相等
class Person
{
public:
	Person(string name, int age)
	{
		this->m_Name = name;
		this->m_Age = age;
	}
	string m_Name;
	int m_Age;
};
template<class T>
bool myCompare(T &a, T &b)
{
	if (a == b)
	{
		return true;
	}
	return false;
}

//利用具体化的Person实现代码，具体化优先调用
template<>bool myCompare(Person& p1, Person& p2)
{
	if (p1.m_Name == p2.m_Name && p1.m_Age == p2.m_Age)
	{
		return true;
	}
	return false;
}
void test01()
{
	int a = 10;
	int b = 20;
	bool ret = myCompare(a, b);
	if (ret)
	{
		cout << "a == b" << endl;
	}
	else
	{
		cout << "a != b" << endl;
	}
}
void test02()
{
	Person p1("Tom", 10);
	Person p2("Tom", 10);
	bool ret = myCompare(p1, p2);
	if (ret)
	{
		cout << "p1 == p2" << endl;
	}
	else
	{
		cout << "p1 != p2" << endl;
	}
}
int main()
{
	test01();
	test02();
	return 0;
}

总结：

• 利用具体化的模板，可以解决自定义类型的通用化
• 学习模板并不是为了写模板，而是在STL能够运用系统提供的模板