目录
前言
C++提供了模板(template)编程的概念。所谓模板，实际上是建立一个通用函数或类，其类内部的类型和函数的形参类型不具体指定，用一个虚拟的类型来代表。这种通用的方式称为模板。模板是泛型编程的基础,泛型编程即以一种独立于任何特定类型的方式编写代码。
C++函数模板的使用
为什么要有函数模板
例如，在一个项目中，有个项目需求是能够实现多个函数用来返回两个数的最大值，要求能支持char类型、int类型、double类型变量。然后呢，根据这个需求，我们写了以下这个代码。
#include <iostream>
using namespace std;
//比较int 类型
int Max(int a, int b)
{
return a > b ? a : b;
}
//比较char 类型
char Max(char a, char b)
{
return a > b ? a : b;
}
//比较float 类型
float Max(float a, float b)
{
return a > b ? a : b;
}
int main(void)
{
int n = 1;
int m = 2;
cout << "max(1, 2) = " << Max(n, m) << endl;
float a = 2.0;
float b = 3.0;
cout << "max(2.0, 3.0) = " << Max(a, b) << endl;
char i = 'a';
char j = 'b';
cout << "max('a', 'b') = " << Max(i, j) << endl;
return 0;
}
执行得到
我们看到，如果我们需要比较多个类型时，需要多个函数，而实际上我们只需要定义一个 “函数” 就能解决。
#include <iostream>
using namespace std;
//template 关键字告诉C++编译器 要开始泛型编程了
//T - 参数化数据类型
template <typename T>
T Max(T a, T b) {
return a > b ? a : b;
}
int main(void)
{
int n = 1;
int m = 2;
cout << "max(1, 2) = " << Max(n, m) << endl;
float a = 2.0;
float b = 3.0;
cout << "max(2.0, 3.0) = " << Max(a, b) << endl;
char i = 'a';
char j = 'b';
cout << "max('a', 'b') = " << Max(i, j) << endl;
return 0;
}
得到的结果是一样的
我们在定义一个函数模板之后，，没有指定类型，编译器会实现参数类型的自动推导。
函数模板语法
所谓函数模板，实际上是建立一个通用函数，其函数类型和形参类型不具体指定，用一个虚拟的类型来代表。这个通用函数就称为函数模板。
凡是函数体相同的函数都可以用这个模板来代替，不必定义多个函数，只需在模板中定义一次即可。在调用函数时系统会根据实参的类型来取代模板中的虚拟类型，从而实现了不同函数的功能。
函数模板定义形式
由以下三部分组成： 模板说明 + 函数定义 + 函数模板调用
template < 类型形式参数表 >
类型 函数名 (形式参数表)
{
//语句序列
}
我们也可以定义多个类型
template <typename T, typename T2>
但是我们定义了一定要用，否则会报错
将代码改成
#include <iostream>
using namespace std;
//template 关键字告诉C++编译器 要开始泛型编程了
//T - 参数化数据类型
template <typename T, typename T2>
T Max(T a, T2 b) {
return a > b ? a : b;
}
int main(void){
int n = 6;
int m = 9;
cout << Max(n, m) << endl;
system("pause");
return 0;
}
1.模板说明
template < 类型形式参数表 >
类型形式参数的形式：
typename T1 , typename T2 , …… , typename Tn
或 class T1 , class T2 , …… , class Tn
（注意： typename 和 class 的效果是一样的，不过建议呢使用typename，为了防止用class有歧义）
2.函数定义
类型 函数名 (形式参数表)
{
}
注意： 模板说明的类属参数必须在函数定义中出现一次,函数参数表中可以使用类属类型参数，也可以使用一般类型参数
3.函数模板调用
Max<int,int>(a, b); //显式类型调用
Max(a, b); //自动数据类型推导
我们再来看以下代码
#include <iostream>
using namespace std;
//template 关键字告诉C++编译器 要开始泛型编程了
//T - 参数化数据类型
template <typename T, typename T2>
T Max(T a, T2 b) {
return a > b ? a : b;
}
int main(void){
int n = 6;
int m = 9;
char a = 'c'; //'c' 对应的ascll码值是 99
cout << "Max<int, char>(m, a): " << Max<int, char>(m, a) << endl; //显式类型调用
cout << "Max(m, a): " << Max(m, a) << endl; //自动数据类型推导
cout << "Max(a, m): " << Max(a, m) << endl; //自动数据类型推导
return 0;
}
为什么会这样呢？因为我们在定义函数模板的时候第一个类型作为了函数类型。
模板函数
也就是，在我们编译的时候，编译器内部会自动生成这些模板函数，然后再进行调用，当然，这些都是编译器内部生成的，我们可以不用去了解太深，我们知道这个概念就可以了。
如果我们来比较类的两个对象
#include <iostream>
using namespace std;
//定义一个类
class Son {
public:
Son(int age) { m_age = age; }
~Son(){}
int getAge() { return m_age; }
private:
int m_age;
};
//template 关键字告诉C++编译器 要开始泛型编程了
//T - 参数化数据类型
template <typename T, typename T2>
T Max(T a, T2 b) {
return a > b ? a : b;
}
int main(void){
Son s1(18);
Son s2(21);
cout << "Max(s1, s2): " << Max(s1, s2).getAge() << endl;
/*
* 模板函数 在类的对象中， 不认识 > 这个符号
Son Max(Son s1, Son s2){
return a > b ? a : b;
}
*/
return 0;
}
就会出现这样的错误
因为在类对象的比较中，不认识这个 > 的符号，所以我们想要能成功执行，我们得在类中实现 > 的运算符重载
#include <iostream>
using namespace std;
//定义一个类
class Son {
public:
Son(int age) { m_age = age; }
~Son(){}
int getAge() { return m_age; }
//重载 > 运算符
bool operator >(Son& res) {
if (this->m_age > res.m_age) return true;
return false;
}
private:
int m_age;
};
//template 关键字告诉C++编译器 要开始泛型编程了
//T - 参数化数据类型
template <typename T, typename T2>
T Max(T a, T2 b) {
return a > b ? a : b;
}
int main(void){
Son s1(18);
Son s2(21);
cout << "Max(s1, s2): " << Max(s1, s2).getAge() << endl;
/*
* 模板函数 在类的对象中， 不认识 > 这个符号
Son Max(Son s1, Son s2){
return a > b ? a : b;
}
*/
return 0;
}
这样就可以执行得出结果了
函数模板和函数重载
我们先来看一下这个demo
#include <iostream>
using namespace std;
template <typename T>
void Test(T& a, T& b) {
T c;
c = a;
a = b;
b = c;
cout << "Test 函数模板被调用了.." << endl;
}
void Test(int& a, int& b) {
int c;
c = a;
a = b;
b = c;
cout << "Test 普通函数被调用.." << endl;
}
int main(void) {
int n = 99;
int m = 65;
Test(n, m);
return 0;
}
这是来观察，当存在函数模板和普通对应的函数的时候，会调用哪个函数
可以看到 当函数模板和普通函数并存的时候，参数类型会和普通重载函数更加匹配
我们把普通函数注释掉，我们才能看到调用函数模板
如果普通函数和函数模板都在的情况下，我们非要使用函数模板，这个怎么实现呢，很简单，如果显式的使用函数模板,则使用<> 类型列表。
如果我们将一个传递的参数改为别的类型
不存在对应的普通函数，函数模板不会提供隐式的类型转换，必须是严格的类型匹配
函数模板和普通函数区别结论：
两者允许并存
函数模板不允许自动类型转化
如果有函数模板和普通函数的时候，普通函数的参数类型不不一致的时候，也会调用普通函数，因为会有隐式的转换，但是如果有函数模板的时候，函数模板会产生更好的匹配，使用函数模板。
有更好的函数模板的时候，会选择函数模板
嵌套使用函数模板
在函数模板中，我们也可以嵌套使用函数模板。
#include <iostream>
using namespace std;
template<typename T>
T Max(T a, T b)
{
cout << "调用 T Max(T a, T b)" << endl;
return a > b ? a : b;
}
template <typename T>
T Max(T a, T b, T c) {
cout << "调用 T Max(T a, T b, T c)" << endl;
return Max(Max(a, b), c);
}
int main(void) {
int a = 1;
int b = 2;
int c = 3;
Max(a, b, c);
system("pause");
return 0;
}
注意：嵌套中的函数要声明在这个函数之前，否则编译器会找不到哪个函数，然后会报错
函数模板和普通函数在一起，调用规则
1 函数模板可以像普通函数一样被重载
2 C++编译器优先考虑普通函数
3 如果函数模板可以产生一个更好的匹配，那么选择模板
4 可以通过空模板实参列表的语法限定编译器只通过模板匹配
在Linux中反汇编查看函数模板被调用的机制
在Linux创建一个cpp文件
保存退出之后编译生成指定的汇编的文件
然后查看这个汇编文件，找到我们熟悉的main函数
再执行一个有函数模板的CPP文件
在main函数中调用了函数模板
从上面可以看出，我们只是定义了一个函数模板，而在调用的时候，内部会自动帮我们生成一个模板函数，然后再执行这个模板函数，得到我们想要的结果
结论
- 编译器并不是把函数模板处理成能够处理任意类型的函数
- 编译器从函数模板通过具体类型产生不同的函数