1：模板的概念
C++中不止有 面向对象编程思想，还要泛型编程思想。而泛型编程思想的核心就是 模板
模板的建立大大提搞了复用行，C++中的模板包括 ：函数模板和类模板。
2：函数模板基本语法
函数模板
概念：
建立一个通用的函数，其函数返回值类型和形参类型可以不具体指定，用一个虚拟的类型来代表，比如现在有个函数 func的声明为 void func(int a) , 我们可以让其成为一个模板，形参类型与返回值类型用 虚拟的 T 表示， 那么 func函数模板的声明为 ： T func(T a);
语法
template <typename T>
函数声明或定义
解释：
template -----声明创建模板
typename ------表明后面的符号是一种数据类型，可以用 class 代替
T ------通用的数据类型，名称可以替代，通常为大写字母。
案例
如果现在我们想实现一个能交换两个变量的值得函数，如果不使用函数模板，针对 整型，浮点型，字符型等不同数据类型的变量，我们需要分别给出对应的函数定义。
不使用函数模板的写法
#include<iostream>
using namespace std;
// 交换整型函数
void swapInt(int& a,int& b) {
int temp = a;
a = b;
b = temp;
}
// 交换浮点函数
void swapFloat(float& a, float& b) {
float temp = a;
a = b;
b = temp;
}
int main() {
int a = 10, b = 20;
float c = 10.0, d = 20.0;
swapInt(a, b);
swapFloat(c, d);
cout << "a = " << a << " b = " << b << endl;
cout << "c = " << c << " d = " << d << endl;
}
// 打印结果
a = 20 b = 10
c = 20 d = 10
使用模板函数的写法
#include<iostream>
using namespace std;
// 交换函数
template<typename T>
void swapFunc(T& a,T& b) {
T temp = a;
a = b;
b = temp;
}
int main() {
int a = 50, b = 80;
float c = 90.0, d = 100.0;
swapFunc(a, b);
swapFunc(c, d);
cout << "a = " << a << " b = " << b << endl;
cout << "c = " << c << " d = " << d << endl;
}
// 打印结果
a = 80 b = 50
c = 100 d = 90
总结：
1：函数模板利用关键字 template
2: 使用函数模板有两种方式： 自动类型推导，显示指定类型
3：模板的目的是为了提高复用性，将类型参数化
3：函数模板注意事项
1： 自动类型推导：必须推导出一致的数据类型 T ，才可以使用。
2： 模板必须要确定出T 的数据类型，才可以使用。
解决方案：直接在调用的时候加上 : 尖括号并给出具体类型
4：普通函数和函数模板的区别
1： 普通函数调用时可以发生自动类型转换（隐式类型转换）
2：函数模板调用时
------如果利用自动类型推导，不会发生隐式类型转换
------如果利用显示指定类型的方式，可以发生隐式类型转换
3：建议使用显示指定类型的方式，调函函数模板时，因为可以自己确定通用类型T
5： 普通函数与函数模板的调用规则
1： 如果函数模板和普通函数都可以实现功能，那么优先使用普通函数
2： 可以通过空模板参数列表来强制调用函数模板
3：函数模板也可以有 重载的发生。
4：如果函数模板可以产生更好的匹配，优先调用函数模板
虽然通过隐式转换来调用普通函数，但是函数模板也可以推导出T 为char ，但是优先匹配函数模板
6： 函数模板的局限性
局限性： 模板的通用性并不是万能的
案例： 我们编写一个函数模板事项对比两个形参，如果相等则返回 true, 对于内置的数据类型（int , char ,long , double） 可以直接使用 == 进行对比，但是对弈一些自定义的数据类型就不能直接使用 == 进行对比。
例如：我们有个 Person类，里面有string 类型的成员变量 name, 还有int 类型的成员变量 age, 如果这两个成员变量都相等则表明这两个变量相等。如果直接向函数模板传入Person类并进行对比，那么是会报错的。
#include <iostream>
#include <string>
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;
}
else
{
return false;
}
}
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() {
test02();
system("pause");
return 0;
}
// 打印内容
已启动生成…
1>------ 已启动生成: 项目: MainDemo6, 配置: Debug Win32 ------
1>main.cpp
1>D:\C++\MainDEMO6\main.cpp(21,8): error C2676: 二进制“==”:“T”不定义该运算符或到预定义运算符可接收的类型的转换
1> with
1> [
1> T=Person
1> ]
1>D:\C++\MainDEMO6\main.cpp(35): message : 查看对正在编译的函数 模板 实例化“bool myCompare<Person>(T &,T &)”的引用
1> with
1> [
1> T=Person
1> ]
1>已完成生成项目“MainDEMO6.vcxproj”的操作 - 失败。
========== 生成: 成功 0 个，失败 1 个，最新 0 个，跳过 0 个 ==========
解决方案：为这些特定的类型提供具体化的模板
#include<iostream>
using namespace std;
#include <string>
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;
}
else
{
return false;
}
}
//具体化，显示具体化的原型以template<>开头，并通过名称Person来指出类型
//具体化优先于常规模板
template<> bool myCompare(Person& p1, Person& p2)
{
if (p1.m_Name == p2.m_Name && p1.m_Age == p2.m_Age)
{
return true;
}
else
{
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);
//自定义数据类型，不会调用普通的函数模板
//可以创建具体化的Person数据类型的模板，用于特殊处理这个类型
bool ret = myCompare(p1, p2);
if (ret)
{
cout << "p1 == p2 " << endl;
}
else
{
cout << "p1 != p2 " << endl;
}
}
int main() {
test01();
test02();
system("pause");
return 0;
}
// 打印结果
a != b
p1 == p27： 总结
1： 利用具体化的模板，可以解决自定义类型的通用化
2：学习函数模板并不是为了写模板，而是能在 STL中能够运用系统提供的模板
