Day 16 C++提高之模板
一、模板的概念
模板就是建立通用的模具，大大提高复用性。例如，生活中的模板：一寸照片的模板、PPT模板、论文模板。
模板特点：通用性很强，但是不能直接使用，只是一个框架，模板不是万能的，需要根据自身内容进行修改
二、函数模板
C++中另一种编程思想就是泛型编程，主要利用的技术就是模板。C++提供两种模板机制，函数模板和类模板
1.函数模板的语法
函数模板的作用：建立一个通用函数，其函数返回值类型和形参类型可以不具体指定，用一个虚拟的类型来代表。在使用的时候再具体指定
语法：
c++
template<typename T>
函数的声明或定义解释：
template ----- 声明创建模板，告诉编译器要写模板了
typename ----- 表明其后面的符号是一种数据类型，可以用class代替，告诉编译器我的后面是一个通用的东西
T -----通用的数据类型，名称（T）可以替换，通常为大写字母，一般用T
c++
//交换两个整型的函数
void swapInt(int& a, int& b)
{
int temp = a;
a = b;
b = temp;
}
//交换两个浮点型的函数
void swapDouble(double &a,double &b)
{
double temp = a;
a = b;
b = temp;
}
//函数模板
template<typename T> //要声明一个模板，告诉编译器T是通用模板，通用的数据类型
void mySwap(T& a, T& b)
{
T temp = a;
a = b;
b = temp;
}
void test01()
{
int a = 10;
int b = 20;
//swapInt(a, b);//原来的交换函数
//利用函数模板进行交换
//有两种方式使用函数模板
//1.自动类型推导
//mySwap(a, b);//根据传入的数据自己推导
//2.显示指定类型
mySwap<int>(a, b);//在<>中告知编译器这是什么类型
cout << "a = " << a<< endl;
cout << "b = " << b<< endl;
/*double c = 1.1;
double d = 2.2;
swapDouble(c, d);
cout << "c = " << c << endl;
cout << "d = " << d << endl;*/
}2.函数模板的注意事项
- 自动类型推导，必须推导出一致的数据类型 T 才可以使用；
- 模板必须要确定出 T 的数据类型，才可以使用。
c++
//函数模板的注意事项
template<class T>//typename可以替换成class
void mySwap(T& a, T& b)
{
T temp = a;
a = b;
b = temp;
}
//1.自动类型推导，必须要推导出一致的数据类型T才可以使用
void test01()
{
int a = 10;
int b = 20;
char c = 'c';
mySwap(a, b);//正确，推导出的T一致
//mySwap(a, c);//错误，推导出的T不一致
cout << "a = " << a << endl;
cout << "b = " << b << endl;
}
//2.模板必须要确定出T的数据类型才可以使用
template<class T>
void func()
{
cout << "func函数的调用" << endl;
}
void test02()
{
//func();//错误，不知道T是什么类型
func<int>();//正确，指定了T的类型
}使用模板时必须要确定出通用数据类型T，并且能够推导出一致的类型
3.函数模板的案例
案例描述：利用函数模板封装一个排序的函数，可以对不同数据类型的数组进行排序；排序规则从大到小，排序算法为选择排序；分别利用char数组和int数组进行测试。
c++
//通用的交换数据的函数模板
template<class T>
void mySwap(T &a, T &b)
{
T temp = a;
a = b;
b = temp;
}
template<class T>
//排序的算法模板
void mySort(T A[],int len)
{
//选择排序
for (int i = 0; i < len; i++)
{
int max = i;//每次认定最大值为开始遍历的这个数
for (int j = i + 1; j < len; j++)
{
if (A[j] > A[max])//比较每个值与max的值
{
max = j;//若现在的大，就更新max的下标，最终的max为当前剩下数组的最大值下标
}
}
if (max != i)//如果比较出来的最大值的下标不等于当轮的初始最大值，就交换二者的位置
{
mySwap(A[max], A[i]);
}
}
}
//打印数组的模板
template<class T>
void myPrint(T arr[],int len)
{
for (int i = 0; i < len; i++)
{
cout << arr[i] << " ";//空格分割，不换行
}
cout << endl;//换行
}
void test01()
{
char charArr[] = "bascgdfe";//测试的char数组
//int number = sizeof(charArr) / sizeof(char);
//mySort(charArr, number);
//myPrint(charArr, number);
//测试int数组
int intArr[] = { 7,4,9,2,1,6,8,0,3,5 };
int number = sizeof(intArr) / sizeof(int);
mySort(intArr, number);
myPrint(intArr, number);
}4.普通函数与函数模板的区别
- 普通函数调用时可以发生自动类型转换（隐式类型转换）；
- 函数模板调用时，如果利用自动类型推导，不会发生隐式类型转换；如果利用显示指定类型的方式，就可以发生隐式类型转换
c++
//普通函数
int myAdd(int a, int b)
{
return a + b;
}
//函数模板
template<class T>
T myAdd02(T a, T b)
{
return a + b;
}
void test01()
{
int a = 7;
int b = 8;
char c = 'c';
//普通函数的调用
//cout << myAdd(a, b) << endl;//15
//cout << myAdd(a, c) << endl;//c发生隐式类型转换，c=99，ASCII码
//函数模板调用
//1.自动类型推导，不会发生隐式类型转换
cout << myAdd02(a, b) << endl;//正确，可以推导出一致类型,15
//cout << myAdd02(a, c) << endl;//报错，因为不可以推导出一致类型
//2.显示指定类型。会发生隐式类型转换
cout << myAdd02<int>(a, c) << endl;//106,正确，指定类型，将c转换成int类型
cout << myAdd02<char>(a, c) << endl;//j,正确，计算之后输出char类型的数据
}提示：推荐只用显示指定类型的方式调用函数模板，因为可以自己确定通用类型的T是什么数据类型
5.普通函数与函数模板的调用规则
调用规则：
- 如果函数模板和普通函数都可以实现，优先调用普通函数；
- 可以通过空模板参数列表来强调函数模板；
- 函数模板也可以发生重载；
- 如果函数模板可以产生更好的匹配，优先调用函数模板
c++
//普通函数
void myPrint(int a, int b)
{
cout << "调用的是普通函数" << endl;
}
//函数模板
template<class T>
void myPrint(T a, T b)
{
cout << "调用的是函数模板" << endl;
}
//函数模板的重载
template<class T>
void myPrint(T a, T b, T c)
{
cout << "调用的是重载的函数模板" << endl;
}
void test01()
{
int a = 7;
int b = 8;
myPrint(a, b);//普通函数和函数模板函数名相同时，会优先调用普通函数,这时，普通函数必须实现
//通过空模板的参数列表强制调用函数模板
myPrint<>(a, b);
myPrint(a, b, 100);//调用的是重载的函数模板
//如果函数模板产生更好的匹配，优先调用函数模板
char c1 = 'a';
char c2 = 'b';
myPrint(c1, c2);//调用的是函数模板，因为普通函数还要作转换，函数模板不用隐式类型转换
}提供了函数模板就不要写普通函数了，容易出现二义性
6.模板的局限性
模板的通用性不是万能的，例如
c++
template<class T>
void func(T a,T b)
{
a=b;//如果传入的是两个数组，那么就无法实现赋值操作
}
//例2
template<class T>
void func(T a,T b)
{
if(a>b){......}//如果T是Person自定义数据类型，也无法正常进行
}因此C++为了解决这种问题，提供模板的重载，可以为这些特定的类型提供具体化的模板
c++
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<>告知这是一个重载的函数模板
template<> bool myCompare(Person& a, Person& b)
{
if (a.m_name == b.m_name && a.m_age == b.m_age)
{
return true;
}
else
{
return false;
}
}
void test01()
{
int a = 8;
int b = 7;
bool ret = myCompare(a, b);
if (ret)
{
cout << "a==b" << endl;
}
else
{
cout << "a!=b" << endl;
}
}
void test02()
{
Person p1{ "懒羊羊",10 };
Person p2{ "喜羊羊",13 };
bool ret = myCompare(p1, p2);
if (ret)
{
cout << "p1==p2" << endl;
}
else
{
cout << "p1!=p2" << endl;
}
}利用具体化的模板，可以解决自定义类型的通用化；学习模板并不是写模板，而是在STL中能够运用系统提供的模板
三、类模板
1.类模板语法
类模板作用：建立一个通用类，类中的成员数据类型可以不具体指定，用一个虚拟的类型来代表
语法：
c++
template<typename T>
类的创建解释：
- template --- 声明下面要创建一个模板
- typename ---表明后面的符号是一种通用的数据类型，可以用class代替
- T --- 通用的数据类型，名称可以替换，通常为大写字母
c++
template<class NameType,class AgeType>//类中两个属性的类型不一样，所以写两个通用数据类型NameType和AgeType
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;//两个属性的类型不一样，所以写两个通用数据类型NameType和AgeType
AgeType m_Age;
};
void test01()
{
Person<string, int> p1("懒羊羊", 10);//<>中表示模板的参数列表
//输出成员信息
p1.showPerson();
}类模板和函数模板语法很相似，在声明模板template后面紧跟创建一个类，这个类就是类模板
2.类模板与函数模板的区别
区别在于两点：
- 类模板没有自动类型推导的使用方式
- 类模板在模板参数列表中可以有默认参数
c++
//在最开始写通用类型的时候，直接指定，(区别2）AgeType=int就可以，下面创建对象时，显示指定类型就可以省略int
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()
{
//区别1：类模板没有自动类型推导使用方式
//Person p("懒羊羊",10);//报错，类模板无法使用自动类型推导，必须使用显示指定类型
Person<string, int> p("懒羊羊", 10);//正确，使用显示指定类型
p.showPerson();
//区别2：类模板在模板参数列表中可以有默认参数
Person<string>p1("喜羊羊", 13);//在最开始写通用类型的时候，直接指定，AgeType=int就可以，这里就可以省略int
}3.类模板中成员函数创建时机
类模板中成员函数和普通类中的成员函数创建时机是有区别的：
- 普通类中的成员函数一开始就可以创建
- 类模板中的成员函数在调用时才创建
c++
class Person1
{
public:
void showPerson1()
{
cout << "showPerson1" << endl;
}
};
class Person2
{
public:
void showPerson2()
{
cout << "showPerson2" << endl;
}
};
template<class T>
class myClass
{
public:
//成员1
T obj;
//类模板中的成员函数
void func1()
{
obj.showPerson1();//这两个成员函数只要不调用就不会创建
}
void func2()
{
obj.showPerson2();
}
};
void test01()
{
myClass<Person1>m;
m.func1();//正确，m的类型是Person1，showPerson1就是Person1的成员函数，所以可以调用
m.func2();//报错，因为showPerson2不是Person1的成员函数，不可以调用
}类模板中的成员函数并不是一开始就创建的，而是在调用的时候才会去创建。
4.类模板对象作函数参数
类模板实例化出对象，向函数传参的方式
一共三种传入方式：
- 指定传入的类型 --- 直接显示对象的数据类型
- 参数模板化 --- 将对象中的参数变为模板进行传递
- 整个类模板化 --- 将这个对象类型模板化进行传递
c++
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;
};
//1.指定传入类型
void printPerson1(Person<string,int> &p)
{
p.showPerson();
}
//2.将参数模板化
template<class NameType,class AgeType>
void printPerson2(Person<NameType,AgeType>&p)//将参数列表的类型也模板化
{
p.showPerson();
//看编译器推出来的类型是什么类型
cout << "NameType的类型为：" << typeid(NameType).name() << endl;
cout << "AgeType的类型为：" << typeid(AgeType).name() << endl;
}
//3.将整个类模板化
template<class T>
void printPerson3(T &p)//将前面的Person这一整个类模板化为T
{
p.showPerson();
cout << "T的数据类型：" << typeid(T).name() << endl;
}
void test01()
{
Person<string, int>p("懒羊羊", 10);
printPerson1(p);//1.指定传入类型
Person<string, int>p2("喜羊羊", 13);
printPerson2(p2);//2.将参数模板化
Person<string, int>p3("沸羊羊", 13);
printPerson3(p3);//3.将整个类模板化
}一般在实际工作中，最常用的就是第一种，指定传入类型
5.类模板与继承
当类模板碰到继承时，需要注意以下几点：
- 当子类继承的父类是一个类模板时，子类在声明的时候，需指定出父类中 T（通用数据类型）的类型；如果不指定，编译器无法给子类分配内存。
- 如果想灵活指定出父类中 T 的类型，子类也需要变为类模板
c++
template<class T>
class Base
{
public:
T m;
};
//class Son :public Base//报错，缺少类模板base的参数列表
class Son:public Base<int>//这里指定了父类Base的通用类型是int，可以正常继承
{
//发生继承时，必须要指定父类的通用数据类型的类型是什么？
//但是一旦指定了，父类的通用类型就只能是int类型了，无法灵活应用
};
//灵活继承应用
template<class T1,class T2>
class Son2 :public Base<T2>
{
public:
Son2()//构造函数，会在创建对象时自动调用
{
cout << "T1的类型为：" << typeid(T1).name() << endl;
cout << "T2的类型为：" << typeid(T2).name() << endl;
}
T1 obj;
};
void test01()
{
Son s1;
Son2<int, char>s2;//第一个int给Son的T1，第二个char给父类Base的T，这里父类中的m就是char类型了
}如果父类是类模板，子类需要指定出父类中T的数据类型
6.类模板成员函数类外实现
目标：能够掌握类模板中成员函数类外实现
c++
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;
};
//成员函数类外实现
template<class T1,class T2>//因为直接写的话，编译器不知道那是通用数据类型，写一下说明
Person<T1,T2>::Person(T1 name, T2 age)//为了体现这是一个类模板，所以将模板的参数列表也加上去<>
{
//第一个Person是作用域，告知是哪个类的成员函数
this->m_Name = name;
this->m_Age = age;
cout << "构造函数的调用" << endl;
}
template<class T1,class T2>
void Person<T1, T2>::showPerson()//若不写<>就是一共正常的成员函数类外实现，为了体现是一共类模板，所以加上<>
{
cout << "姓名：" << this->m_Name << " 年龄：" << this->m_Age << endl;
}
void test01()
{
Person<string, int> p1("懒羊羊", 10);
p1.showPerson();
}7.类模板分文件编写
目标：掌握类模板成员函数分文件编写，产生的问题以及解决方式
问题：类模板中成员函数创建时机是在调用阶段，导致分文件编写时链接不到
解决：
- 直接包含.cpp源文件
- 将声明和实现写到同一个文件中，并更改后缀名为.hpp，hpp是C++编程者约定的名称，并不是强制的
C++编写时，通常把每个类单独写在一个文件中，.h文件中写类的声明以及成员函数的声明，然后再.CPP文件中写成员函数具体的实现
第一种解决办法：将原先的包含头文件.h，改为包含.cpp文件
c++
#include<iostream>
using namespace std;
#include<string>
//1.直接包含.cpp文件
#include"person.cpp"
void test01()
{
Person<string, int>p1("懒羊羊", 10);
p1.showPerson();
}第二种解决办法：.h和.cpp文件的内容写在一个文件中，然后将.h文件后缀名改为.hpp文件，然后包含.hpp文件
c++
//2.包含.hpp文件
#include"person.hpp"
void test01()
{
Person<string, int>p1("懒羊羊", 10);
p1.showPerson();
}
//person.hpp文件的代码
#pragma once
#include<iostream>
using namespace std;
#include<string>
template<class T1,class T2>
class Person
{
public:
Person(T1 name, T2 age);
void showPerson();
T1 m_Name;
T2 m_Age;
};
template<class T1, class T2>
Person<T1, T2>::Person(T1 name, T2 age)
{
this->m_Name = name;
this->m_Age = age;
}
template<class T1, class T2>
void Person<T1, T2>::showPerson()
{
cout << "姓名：" << this->m_Name << " 年龄：" << this->m_Age << endl;
}因为类模板的成员函数创建时机是调用它时。主流的解决办法是第二种方式，将类模板成员函数的声明和实现写在一起，并将.h文件的后缀名改为.hpp，然后不需要源文件.cpp
8.类模板与友元
目标：掌握类模板配合友元函数的类内和类外实现
- 全局函数的类内实现 -- 直接在类内声明友元即可
- 全局函数的类外实现 -- 需要提前让编译器知道全局函数的存在
c++
//1.全局函数类内实现
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>p1("懒羊羊", 10);
printPerson(p1);
}
//2.全局函数类外实现
template<class T1, class T2>
class Person;
//全局函数类外实现，这里是一个函数模板的实现，所以和下面错误的那个不是一个东西，
template<class T1, class T2>
void printPerson2(Person<T1, T2>p)//全局函数，无需加作用域,需要写在前面让编译器提前知道有这个函数的存在
{
cout << "类外实现 -- 姓名：" << p.m_Name << " 类外实现 -- 年龄：" << p.m_Age << endl;
}
//通过全局函数打印Person的信息
template<class T1,class T2>
class Person
{
//全局函数，类外实现
//friend void printPerson2(Person<T1, T2>p);//这是一个普通函数的声明，所以加一个空模板的<>参数列表
friend void printPerson2<>(Person<T1, T2>p);//如果是类外实现，就需要让编译器提前知道有这样一个函数模板存在
public:
Person(T1 name, T2 age)
{
this->m_Name = name;
this->m_Age = age;
}
private:
T1 m_Name;
T2 m_Age;
};
//全局函数在类内实现
void test01()
{
//全局函数在类外实现测试
printPerson2(p1);
}建议写全局函数类内实现，用法简单，编译器可以直接识别。不建议类外实现，稍微复杂