c++提供了函数模板(function template.)所谓函数模板，实际上是建立一个通用函数，其函数类型和形参类型不具体制定，用一个虚拟的类型来代表。这个通用函数就成为函数模板。凡是函数体相同的函数都可以用这个模板代替，不必定义多个函数，只需在模板中定义一次即可。
- c++提供两种模板机制:函数模板和类模板
目录
一、函数模板
语法：
template< typename T > T是通用的数据类型
函数名(T&形参1 T&形参2....){ 函数实现 }
1.1 函数模板和普通函数区别
- 函数模板不允许自动类型转化，必须严格匹配类型。
- 普通函数能够自动进行类型转化
1.2 函数模板和普通函数在一起调用规则
- c++编译器优先考虑普通函数
- 如果想强制调用函数模板，需要加 空模板参数列表
- 函数模板可以像普通函数那样可以被重载
- 如果函数模板可以产生一个更好的匹配（不发生类型转化），那么选择模板
void myPrint(int a, int b)
{
cout << "普通函数myPrint调用" << endl;
}
template<class T>
void myPrint(T a, T b)
{
cout << "函数模板myPrint调用" << endl;
}
template<class T>
void myPrint(T a, T b,T c)
{
cout << "函数模板myPrint(a,b,c)调用" << endl;
}
void test02()
{
//1、如果普通函数和函数模板都可以匹配，优先使用普通函数
int a = 10;
int b = 20;
myPrint(a, b);
//2、如果想强制调用函数模板，需要加 空模板参数列表
myPrint<>(a, b);
//3、函数模板也可以发生函数重载
myPrint(a, b, 10);
//4、如果函数模板可以产生更好的匹配，那么优先使用函数模板
char c1 = 'c';
char c2 = 'd';
myPrint(c1, c2);
}
二、模板机制剖析
2.1编译过程
hello.cpp程序是高级c语言程序，这种程序易于被人读懂。为了在系统上运行hello.c程序，每一条c语句都必须转化为低级的机器指令。然后将这些机器指令打包成可执行目标文件格式，并以二进制形式存储于磁盘中。
预处理(Pre-processing) -> 编译(Compiling) ->汇编(Assembling) -> 链接(Linking)
2.2 模板实现机制
函数模板机制结论：
- 编译器并不是把函数模板处理成能够处理任何类型的函数
- 函数模板通过具体类型产生不同的函数
- 编译器会对函数模板进行两次编译，第一次在声明的地方对模板代码本身进行编译，第二次在调用的地方对参数替换后的代码进行编译。
2.3模板的局限性
函数模板并不是万能，对于自定义类型数据，有些情况不能够正常使用
解决方法：可以利用具体化实现
语法：template <> 返回值类型 函数名 (处理数据类型..)
例子：
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)
{
return a == b;
}
//具体语法实现
template<> bool myCompare(Person &a, Person&b)
{
cout << "具体化实现" << endl;
if (a.m_Name == b.m_Name && a.m_Age == b.m_Age)
{
return true;
}
return false;
}
void test02()
{
Person p1("Tom", 10);
Person p2("Tom", 10);
bool ret = myCompare(p1, p2);
if (ret)
{
cout << "p1==p2" << endl;
}
}
三、类模板
类模板和函数模板的定义和使用类似，我们已经进行了介绍。有时，有两个或多个类，其功能是相同的，仅仅是数据类型不同。
例子：
//可以使用默认参数
template<class NAMETYPE , class AGETYPE = int>
class Person
{
public:
Person(NAMETYPE name, AGETYPE age)
{
this->m_Name = name;
this->m_Age = age;
}
void showPerson()
{
cout << "姓名： " << this->m_Name << " 年龄： " << this->m_Age << endl;
}
NAMETYPE m_Name;
AGETYPE m_Age;
};
void test01()
{
//Person p1("Tom", 20); 类模板使用时候，不可以用自动类型推导，只能用显示指定类型
Person <string>p1("Tom", 20);
p1.showPerson();
}
3.1 类模板做函数参数
可以有3中情况：
- 1、指定传入类型
- 2、将参数模板化
- 3、将类模板化
//模板中 也可以使用默认参数
template<class T1, class T2>
class Person
{
public:
Person(T1 name, T2 age)
{
this->m_Name = name;
this->m_Age = age;
}
void showPerson()
{
cout << "姓名： " << this->m_Name << " 年龄： " << this->m_Age << endl;
}
T1 m_Name;
T2 m_Age;
};
//1、指定传入类型
void doWork(Person <string, int>&p)
{
p.showPerson();
}
void test01()
{
Person <string,int>p1("Tom", 100);
doWork(p1);
}
//2、将参数模板化
template<class T1,class T2>
void doWork2(Person <T1, T2>&p)
{
cout << "T1 = " << typeid(T1).name() << endl;
cout << "T2 = " << typeid(T2).name() << endl;
p.showPerson();
}
void test02()
{
Person <string, int>p1("Jerry", 100);
doWork2(p1);
}
//3、将类模板化
template<class T>
void doWork3(T &p)
{
cout << "T = " << typeid(T).name() << endl;
p.showPerson();
}
void test03()
{
Person <string, int>p1("Bill", 100);
doWork3(p1);
}
3.2 类模板派生普通类
- 子类在继承时，必须确定出父类的T的数据类型，否则无法给T分配内存空间
//类模板
template<class T>
class MyClass{
public:
MyClass(T property){
this->mProperty = property;
}
public:
T mProperty;
};
//子类实例化的时候需要具体化的父类，子类需要知道父类的具体类型是什么样的
//这样c++编译器才能知道给子类分配多少内存
//普通派生类
class SubClass : public MyClass<int>{
public:
SubClass(int b) : MyClass<int>(20){
this->mB = b;
}
public:
int mB;
};
3.3 类模板头文件和源文件分离问题
类模板的声明和实现放到一个文件中，我们把这个文件命名为.hpp(这个是个约定的规则，并不是标准，必须这么写).
原因：
- 类模板需要二次编译，在出现模板的地方编译一次，在调用模板的地方再次编译。
- C++编译规则为独立编译。
3.4 模板类碰到友元函数（类内实现）
template<class T1,class T2>
class Person
{
friend void printPerson(Person<T1, T2>& p)
{
cout << "姓名： " << p.m_Name << " 年龄： " << p.m_Age << endl;
}
public:
Person(T1 name, T2 age)
{
this->m_Name = name;
this->m_Age = age;
}
private:
T1 m_Name;
T2 m_Age;
};
void test01()
{
Person<string, int>p("Tom", 111);
printPerson(p);
}