C++第十八次课——模板（函数模板，类模板）

1、模板的概念

就是建立通用的模具，大大提高复用性

2、函数模板

C++的一种变成思想称为泛型编程， 主要利用的技术就是模板
C++提供两种模板机制：函数模板和类模板

2.1 函数模板

作用： 建立一个通用函数，其函数返回值类型和形参类型可以不具体制定，用一个虚拟的类型来代表
语法： template < typename T>
解释：
template — 声明创建模板
typename — 表明其后面的符号是一种数据类型，可以用class代替
T — 通用的数据类型，名称可以替换，通常为大写字母

//函数模板
template<typename T> // 声明一个模板，告诉编译器后面代码中紧跟着的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; 
}

注意事项：
1、自动类型推导，必须推导出一致的数据类型T，才可以使用
2、模板必须要确定出T的数据类型，才可以使用

2.2 普通函数与函数模板的区别

1、普通函数调用时可以发生自动类型转换（隐式类型转换）
2、函数模板调用时，如果利用自动类型推导，不会发生隐式类型转换
3、如果利用显示指定类型的方式，可以发生隐式类型转换

2.3 普通函数与函数模板的调用规则

1、如果函数模板和普通函数都可以实现，优先调用普通函数
2、可以通过空模板参数列表来 ‘强制调用’ 函数模板
3、函数模板也可以发生重载
4、如果函数模板可以产生更好的匹配，优先调用函数模板

2.4 模板的局限性

1、模板的通用性并不是万能的。
2、利用具体化的模板，（加template<>），可以解决自定义类型的通用化
3、学习模板并不是为了写模板，而是在STL能够运行系统提供的模板
4、模板具体化的函数往往出现在库中，其优先级低于普通函数，用户不想用时可以写一个普通函数进行覆盖。

3、类模板

3.1 类模板

作用： 建立一个通用类，类中的成员数据类型可以不具体制定，用一个虚拟的类型来代表
语法： template < typename T>
解释：
template — 声明创建模板
typename — 表明其后面的符号是一种数据类型，可以用class代替
T — 通用的数据类型，名称可以替换，通常为大写字母

3.2 类模板与函数模板区别

1、类模板没有自动类型推导的使用方式
2、类模板在模板参数列中有默认参数

template<class NameType, class AgeType = int>
class Person{
.....
}
void test01(){
	Person<string>p("猪八戒"，999);
}

3.3 类模板中成员函数创建时机

类模板中成员函数和普通类中成员函数创建时机是有区别的：
1、普通类中的成员函数一开始就可以创建
2、类模板中的成员函数在调用时才创建

3.4 类模板对象做函数参数

通过类模板创建的对象，有三种方式向函数中进行传参
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 << "show Person" << endl;
	}
	T1 m_name;
	T2 m_age;
};

//1、指定转入类型
void printPerson1(Person<string, int>&p) {
	p.showPerson();
}
void test01() {
	Person<string,int> p ("孙悟空", 666);
	printPerson1(p);
}

//2、参数模板化
template<class T1, class T2>
void printPerson2(Person<T1, T2>&p) {
	p.showPerson();
}
void test02() {
	Person<string, int> p("猪八戒", 888);
	printPerson2(p);
}

//3、整个类模板化
template<class T>
void printPerson3(T &p) {
	p.showPerson();
}
void test03() {
	Person<string, int> p("唐僧", 100);
	printPerson3(p);
}
//主函数
int main() {
	test03();
	return 0;
}

总结：使用广泛的是第一种，指定传入参数类型

3.5类模板与继承

当类模板碰到继承的时候，需要注意：
1、当子类继承的父类是一个类模板时，子类在声明的时候，需要指定出父类中的类型
2、如果不指定，编译器无法给子类分配内存
3、如果想灵活指定出父类中 T 的类型，子类也需要变为类模板

//类模板与继承
template<class T>
class Base {
	T m;
};

//class Son : public Base { // c错误，必须要知道父类T中的类型，才能继承
class Son :public Base<int> {

};
void test01() {
	Son s1;
}


//如果想灵活地指定父类中T类型，子类也需要变类模板
template<class T1, class T2>
class Son2 :public Base<T2> {
	T1 obj;
};
void test02() {
	Son2<int, char>S2;
}

int main() {
	test01();
	return 0;
}

3.6 类模板成员函数的类外实现

template<class T1, class T2>
Person<T1, T2>::Person(T1 name, T2 age)
void Person<T1, T2>::showPerson()

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) {
	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;
}

void test01() {
	Person<string, int>p("Tom", 20);
	p.showPerson();
}

3.7 类模板分文件编写

类模板的成员函数在分文件编写时产生问题
问题：
类模板中成员函数创建时机是在调用阶段，导致分文件编写时链接不到
解决：
方法1：直接包含.cpp源文件（#include<person.cpp> 而person.cpp中include<person.h>）
方法2：将类模板成员函数的声明.h和实现.cpp写到同一个文件中，并更改后缀名为.hpp，hpp是约定的名称，并不是强制

3.8 类模板与友元

全局函数类内实现 - 直接在类内声明友元接口
全局函数类外实现 - 需要提前让编译器知道全局函数的存在

//2、全局函数配合友元 类外实现- 先做函数模板声明，下方做函数模板定义，再做友元
template<class T1, class T2>
class Person;
//2、类外实现-函数模板定义
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 {
	//1、全局函数， 类内实现
	friend void printPerson(Person<T1, T2> p) {
		cout << "姓名： " << p.m_name << "  年龄：" << p.m_age << endl;
	}
	//2、全局函数， 类外实现(1、加空模板参数列表，2、需要让编译器提前知道整个函数存在)
	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;
};

//1、全局函数在类内实现
void test01() {
	Person<string, int>p("tom", 20);
	printPerson(p);
}

//2、全局函数在类外实现
void test02() {
	Person<string, int>p("jerry", 18);
	printPerson2(p);
}

总结： 类外实现过于复杂，一般用类内实现