C++学习笔记 （21）——模板
主要针对c++泛型编程和STL技术
模板的特点：
- 模板可以直接使用，她只是一个框架
- 模板的通用并不是万能的
c++另一种编程思想称为：泛型编程，主要利用的技术就是模板
c++提供两种模板机制：函数模板 和 类模板
1、函数模板语法
1.1、函数模板作用：
建立一个通用函数，其函数返回值类型和形参类型可以不具体指定，用一个虚拟的类型来代表
语法：
template<typename T>
函数声明或定义
解释：
template —— 声明创建模板
typename ——表面其后面的符号是一种数据类型，可以用class代替
T —— 通用的数据类型 ，名称可以替换，通常为大小写字母
有两种方式使用函数模板：
隐士转换：
- mySwap(a, b);
显示转换：
- mySwap<int>(a, b);
eg：
#include <iostream>
using namespace std;
//函数模板
template<typename T> //声明一个模板，告诉编译器后面代码中紧跟着的T不要报错，T是一个通用的数据的数据类型
void mySwap(T &a, T &b)
{
T temp = a;
a = b;
b = temp;
}
int main()
{
int a = 10;
int b = 29;
cout << "交换前：" << endl;
cout << "a = " << a << endl;
cout << "b = " << b << endl;
//利用函数模板交换两个数的值
//有两种方式使用函数模板
//1.隐式转换
mySwap(a, b);
//2.显示转换
//告诉编译器传入的数据类型是整型
mySwap<int>(a, b);
cout << "交换后：" << endl;
cout << "a = " << a << endl;
cout << "b = " << b << endl;
system("pause");
return 0;
}
1.2、函数模板注意事项
注意事项：
- 自动类型推导，必须推导出一致的数据类型T，才可以使用
- 模板必须要确定T的数据类型，才可以使用
eg：
#include <iostream>
using namespace std;
//函数模板注意事项
template<class T> // typename 可以替换成class
void mySwap2(T& a, T& b)
{
T temp = a;
a = b;
b = temp;
}
//1.自动类型推到，必须推导出一致的数据类型T才可以使用
void test02()
{
int a = 29;
int b = 39;
char c = 'a';
mySwap2(a, b);
//mySwap2(a, c); //T的类型就不明确了，是int 型还是 char型
cout << "a = " << a << endl;
cout << "b = " << b << endl;
}
//2.模板必须要确定出T的数据类型，才可以使用
template<class T> // typename 可以替换成class
void func()
{
}
void test02_1()
{
//func(); //函数实现是空，没有指定T的数据类型，隐式转换推到不出，会报错.
//使用显示
func<int>();
}
int main()
{
test02();
test02_1();
system("pause");
return 0;
}
1.3、普通函数与函数模板的区别
普通函数与函数模板的区别：
- 普通函数调用时可以发生自动类型转换（隐士类型转换）
- 函数模板调用时，如果利用自动类型转换推到，不会发生隐士类型转换
- 如果利用显示指定类型的方式，可以发生隐士类型转换
eg:
#include <iostream>
using namespace std;
//1.普通函数调用可以发生隐式类型转换
//2.函数模板 用自动类型推导，不可以发生隐式类型转换
//3.函数模板 用显示指定类型，可以发生隐式类型转换
//普通函数
int myAdd03(int a, int b)
{
return a + b;
}
//函数模板
template<class T>
T myAdd02_1(T a, T b)
{
return a + b;
}
void test03()
{
int a = 20;
int b = 20;
char c = 'c';
cout << myAdd03(a, c) << endl;
//自动类型推导(会出错)
//cout << myAdd02_1(a, c) << endl;
//显式指定类型就可以
cout << myAdd02_1<int>(a, c) << endl;
}
int main()
{
test03();
system("pause");
return 0;
}
总结：
建议用指定类型调用模板
1.4、普通函数与函数模板的调用规则
- 规则如下:
- 如果函数模板和普通函数都可以实现，优先调用普通函数
- 可以通过空模板参数列表来强调函数模板
- 函数模板也可以发生重载
- 如果函数模可以产生更好的匹配，优先调用函数模板
eg：
#include <iostream>
using namespace std;
void myPrint(int a, int b)
{
cout << "调用的普通和函数" << endl;
}
template<class T>
void myPrint(T a, T b)
{
cout << "调用的函数模板" << endl;
}
void test04()
{
int a = 0;
int b = 9;
myPrint(a, b);
//可以通过空模板强制调用模板函数
myPrint<>(a, b);
char c = 'o';
char d = 'p';
//模板函数可以产生更好的匹配，编译器直接推导使用，不用再char 转in
myPrint<>(a, b);
}
int main()
{
test04();
system("pause");
return 0;
}
1.5、模板的局限性
局限性：
- 模板的通用性并不是万能的
- 有些特定的数据类型，需要用具体化方式做特殊实现
#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;
}
}
//利用具体化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 test05()
{
int a = 0;
int b = 0;
bool ret = myCompare(a, b);
if (ret == true)
{
cout << "a==b" << endl;
}
else
{
cout << "a!=b" << endl;
}
}
void test05_1()
{
Person p1("梨花",45);
Person p2("小菊", 13);
//bool ret = myCompare(p1, p1); //不认识p1 和p2 会报错
bool ret = myCompare(p1, p1); //具体化数据类型之后就可以了
if (ret == true)
{
cout << "p1==p1" << endl;
}
else
{
cout << "p1!=p1" << endl;
}
}
int main()
{
test05();
test05_1();
system("pause");
return 0;
}
2、类模板
2.1、类模板语法：
类模板作用：
- 建立一个通用类，类中的成员，数据类型可以不具体指定，用一个虚拟的类型来代表
语法：
template<class T>
类
解释：
tmplate —— 声明创建模板
class —— 表面其后面的符号是一种数据类型，可以用typename来代替
T —— 通用的数据类型，名称可以替换，通常为大写字母
eg：
#include <iostream>
using namespace std;
//类模板
template<class T1,class T2>
class Person
{
public:
Person(T1 name, T2 age)
{
this->m_Name = name;
this->m_Age = age;
}
T m_Name;
T m_Age;
};
void test01() {
//指定模板数据类型
Person<string,int> p1("小菊",90);
}
int main()
{
system("pause");
return 0;
}
2.2.、类模板与函数模板的区别：
主要有两点：
- 类模板没有自动类型推导的使用方式
- 类模板在模板参数列表中可以有默认参数
2.3、类模板中成员函数创建时机
类模板中成员函数和普通成员函数创建时机是有区别的：
- 普通类中的成员函数一开始就可以创建
- 类模板中的函数在调用时才创建
2.4、类模板对象做函数参数
- 类模板实例化出的对象，像函数传参数的方式
一共有三种传参方式：
- 指定出入的类型 ——直接显示对象的数据类型
- 参数模板化 —— 将象中的参数变为模板进行传递
- 整个类模板化 —— 将这个对象类型模板化进行传递
2.5、 类模板与继承
当类模板碰到继承时，需要注意一下几点：
- 当子类继承的父类是一个模板时，子类在生命的时候，需要制定父类中的T的数据类型
- 如果不指定，编译器无法给子类分配内存
- 如果想灵活指定父类中T的类型，子类也需要变为模板类
2.6、类模板成员函数类外实现
2.7、类模板分文件编写
掌握类模板成员函数分文件编写产生的问题及解决方法
问题？
- 类模板中成员函数创建时机是在调用阶段，导致分文件编写时链接不到
解决：
- 解决方式1：直接包含.cpp源文件
- 解决方式2：将声明和实现写到同一个文件中，并更改后缀名为.hpp，hpp是约定的名称，并不是强制
2.8、类模板与友元
掌握类模板配合友元函数的类内和类外实现
全部函数类内实现——直接在类内声明友元即可
全局函数类外实现 —— 需要提前让编译器知道全局函数的存在
