C++进阶-模板

模板

模板的概念
- 函数模板
- - 函数模板语法
  - 函数模板注意事项
  - 案例-实现数据的排序
  - 函数模板与普通函数的区别
  - 普通函数与函数模板的调用规则
- 模板的局限性
- 类模板的基本语法
- - 类模板与函数模板的区别
  - 类模板中成员函数创建时机
  - 类模板对象做函数参数
  - 类模板与继承
  - 类模板成员函数类外实现
  - 类模板分文件编写
  - - 解决方案-包含整个源文件
    - 解决方案-将声明和实现写到同一个文件中，并更改后缀名为 `.hpp`
  - 类模板与友元

模板的概念

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

模板不可以直接使用，它只是一个框架
模板的通用并不是万能的

函数模板

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

函数模板语法

函数模板作用：建立一个通用函数，其函数返回值类型和形参类型可以不具体制定，用一个虚拟的类型来代表。

语法：
template<typename T>
函数声明或定义

template — 声明创建模板
typename — 表明其后面的符号是一种数据类型，可以用class代替
T — 通用的数据类型，名称可以替换，通常为大写字母

案例说明：
我们以两数字交换的函数来说明，我们写两数交换时，会涉及到不同的类型 int、float等，这会让我们写大量的重复代码：

//两个整形交换的函数
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;
}

实际上，函数中的处理逻辑是一致的，这种时候我们就需要使用我们的模板

#include <iostream>
using namespace std;

//函数模板 声明一个模板，告诉编译器后面代码中紧跟着的T不要报错，T是一个通用数据类型
template<typename T>

//运用模板创建函数
void swapT(T& a, T& b)
{
	T temp = a;
	a = b;
	b = temp;
}

int main()
{
	int a = 10;
	int b = 20;
	//两种方式使用函数模板 ①自动推导类型
	swapT(a, b);
	//②显示指定类型
	swapT<int>(a, b);
	std::cout << "a =" << a << std::endl;
	std::cout << "b =" << b << std::endl;
}

从案例中我们也可以看出我们模板的使用流程：

声明一个模板，告诉编译器后面代码中紧跟着的T不要报错，T是一个通用数据类型：template<typename T>
运用模板创建函数
使用两种方式使用函数模板

我们在调用时，可以有两种方式指定具体的类型：
①自动推导类型

int a = 10;
int b = 20;
swapT(a, b);

②显示指定类
swapT<int>(a, b);

那么经过测试，两种方式都可以实现两数交换的功能

函数模板注意事项

自动类型推导，必须推导出一致的数据类型T才可以使用

自动类型必须推出一致的T才能使用

模板必须要确定出T的数据类型，才可以使用

案例-实现数据的排序

利用函数模板封装一个排序的函数，可以对不同数据类型数组进行排序
排序规则从大到小，排序算法为选择排序
分别利用char数组和int数组及逆行测试

#include <iostream>
using namespace std;

//定义模板类型T
template<typename T>
//定义交换函数
void swapT(T& a, T& b);

//定义模板类型T
template<typename T>
//打印输出数组数据信息
void print_array(T* array, int len);

//定义模板类型T
template<typename T>
//实现不定类型的数组的排序，使用选择排序并从大到小进行排序
void sort_array(T* array, int len);

int main()
{
	char array[] = "aetdhiysjdn";
	int len = sizeof(array) / sizeof(array[0]);
	print_array(array, len);
	sort_array(array, len);
	print_array(array, len);

	int array_int[] = { 34,67,23,77,45,22,56,21 };
	int len_int = sizeof(array_int) / sizeof(array_int[0]);
	print_array(array_int, len_int);
	sort_array(array_int, len_int);
	print_array(array_int, len_int);
}

//定义模板类型T
template<typename T>
//实现不定类型的数组的排序，使用选择排序并从大到小进行排序
void sort_array(T* array, int len)
{
	for (int i = 0; i < len; i++)
	{
		int max_index = i;
		for (int j = i + 1; j < len; j++)
		{
			if (array[max_index] < array[j])
			{
				max_index = j;
			}
		}
		if (max_index != i)
		{
			swapT(array[i], array[max_index]);
		}
	}
}

//定义模板类型T
template<typename T>
//打印输出数组数据信息
void print_array(T* array, int len)
{
	for (int i = 0; i < len; i++)
	{
		std::cout << array[i] << "   ";
	}
	std::cout << std::endl;
}

//定义模板类型T
template<typename T>
//定义交换函数
void swapT(T& a, T& b)
{
	T temp = a;
	a = b;
	b = temp;
}

程序执行结果：

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

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

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

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

#include <iostream>
using namespace std;

//普通函数调用
void printf(int a);

//定义模板类型
template<typename T>
//模板函数调用实例
void printf(T a);

//定义模板类型
template<typename T>
//重载的数据类型
void printf(T a, T b);

int main()
{
	//①如果函数模板和普通函数都可以实现，优先调用普通函数
	printf(10);
	//②可以通过空模板参数列表来表强制调用函数模板
	printf<>(10);
	//③函数模板也可以发生重载
	printf(10, 23);
	//④如果函数模板可以产生更好的匹配，有限调用函数模板
	printf(((char)10));
}

//普通函数调用
void printf(int a)
{
	std::cout << "普通函数调用" << std::endl;
}

//定义模板类型
template<typename T>
//模板函数调用实例
void printf(T a)
{
	std::cout << "调用的模板函数" << std::endl;
}

//定义模板类型
template<typename T>
//重载的数据类型
void printf(T a,T b)
{
	std::cout << "调用的重载的模板函数" << std::endl;
}

程序执行结果

模板的局限性

模板的通用性并不是万能的

template<typename T>
void func(T a, T b)
{
	a = b;
}

如案例中，如果传入的是数组，那么这段代码就无法实现
为了解决这个问题，C++提供了模板的重载，可以为这些特定的类型提供具体化的模板
template<> bool compareT(Person& a, Person& b)

#include <iostream>
#include <string>
using namespace std;

class Person
{
public:
	string name;
	int age;
public:
	Person(string name,int age)
	{
		this->name = name;
		this->age = age;
	}
};

//定义模板
template<class T>
//模板传入参数是否相等
bool compareT(T& a, T& b)
{
	return a == b;
}

//利用具体的特殊的参数定义具体的实现，具体实现优先调用
template<> bool compareT(Person& a, Person& b)
{
	return a.age == b.age && a.name == b.name;
}

int main()
{
	Person a("tom", 12);
	Person b("tom", 13);
	bool isEquales = compareT(a, b);
	if (isEquales) 
	{
		std::cout << "a = b" << std::endl;
	}
	else
	{
		std::cout << "a != b" << std::endl;
	}
}

利用具体化的模板，可以解决自定义类型的通用化
学习模板并不是为了写模板，而是在STL能够运用系统提供的模板

类模板的基本语法

类模板的作用：建立一个通用类，类中的成员数据类型可以不具体制定，用一个虚拟的类型来代表。

语法：

template<typename T>
类

template — 声明创建模板
typename — 表明其后面的符号是一种数据类型，可以用class代替
T — 通用的数据类型，名称可以替换，通常为大写字母

#include <iostream>
#include <string>
using namespace std;

template<class n_T,class a_T>
class Person
{
public:
	n_T name;
	a_T age;
public:
	Person(n_T name, a_T age)
	{
		this->name = name;
		this->age = age;
	}
	void printf()
	{
		std::cout << "name = " << this->name << std::endl;
		std::cout << "age = " << this->age << std::endl;
	}
};

int main()
{
	Person<string,int> p("张三", 12);
	p.printf();
}

程序运行结果：

程序运行结果
类模板和函数模板语法非常相似，在声明模板template后面加类，此类称之为类模板

类模板与函数模板的区别

类模板没有自动类型推导的使用方式，类模板中只能显式指定类型
类模板在模板参数列表中可以有默认参数
template<class n_T,class a_T = int>
class Person{}
只有类模板中才能指定默认类型

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

普通类中的成员函数一开始就可以创建
类模板中的成员函数是在调用时才创建的

#include <iostream>
#include <string>
using namespace std;

class Obj
{
public:
	void printf()
	{
		std::cout << "成功调用了 printf 方法" << std::endl;
	}
};

template<class P>
class Person
{
public:
	P obj;
public:
	void printf()
	{
		obj.printf();
	}
	void printf2()
	{
		obj.printf2();
	}
};



int main()
{
	Person<Obj> person;
	Obj obj;
	person.obj = obj;
	person.printf();
	person.printf2();
}

类模板中的成员函数并不以一开始就创建的，而是在调用时才去创建

类模板对象做函数参数

指定传入的类型 —直接显示对象的数据类型

void print(Person<string, int> p)

参数模板化 —将对象中的参数变为模板进行传递

template<class Name,class Age>
void print_2(Person<Name, Age> p)

整个类模板化 —将这个对象类型模板化进行传递

template<class T>
void print_3(T& p)

案例：使用三种方式具体实现类模板对象做函数参数

#include <iostream>
#include <string>
using namespace std;

template<class Name,class Age>
class Person
{
private:
	Name name;
	Age age;
public:
	Person(Name nam, Age age)
	{
		this->name = name;
		this->age = age;
	}
	void printf()
	{
		std::cout << "name = " << this->name << "  age=" << this->age << std::endl;
	}
};

//①指定传入类型
void print(Person<string, int> p)
{
	p.printf();
}

//②参数模板化
template<class Name,class Age>
void print_2(Person<Name, Age> p)
{
	p.printf();
	std::cout << "Name 的类型为：" << typeid(Name).name() << std::endl;
}

//③整个类模板化
template<class T>
void print_3(T& p)
{
	p.printf();
	std::cout << "p 的类型为：" << typeid(T).name() << std::endl;
}

int main()
{
	Person<string, int> p("张三", 333);
	print(p);
	print_2(p);
	print_3(p);
}

程序运行结果：
程序执行结果

类模板与继承

当类模板碰到继承时，需要注意：

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

#include <iostream>
#include <string>
using namespace std;

template<class Name,class Age>
class Person
{
private:
	Name name;
	Age age;
public:
	Person()
	{

	}
	Person(Name nam, Age age)
	{
		this->name = name;
		this->age = age;
	}
	void printf()
	{
		std::cout << "name = " << this->name << "  age=" << this->age << std::endl;
	}
	void setName(Name name)
	{
		this->name = name;
	}
	void setAge(Age age)
	{
		this->age = age;
	}
};

//①当子类继承的父类是一个类模板时，子类在声明的时候，需要指定出父类中`T`的类型
class Man :public Person<string,int>
{
public:
	Man()
	{

	}
};

//②如果想灵活指出父类的`T`的类型，子类也需要变为类模板
template<class Name, class Age>
class Woman :public Person<Name, Age>
{
public:
	Woman()
	{

	}
};

int main()
{
	Man man;
	man.printf();
	man.setName("测试的man");
	man.setAge(12);
	Woman<string,int> woman;
	woman.setAge(24);
	woman.setName("测试的woman");
	woman.printf();
}

程序运行结果：

程序运行结果

类模板成员函数类外实现

#include <iostream>
#include <string>
using namespace std;

template<class Name,class Age>
class Person
{
private:
	Name name;
	Age age;
public:
	Person(Name nam, Age age);
	void printf();
};

//类外实现构造函数
template<class Name, class Age>
Person<Name,Age>::Person(Name nam, Age age)
{
	this->name = name;
	this->age = age;
}

//类外实现成员函数
template<class Name, class Age>
void Person<Name, Age>::printf()
{
	std::cout << "name = " << this->name << "  age=" << this->age << std::endl;
}

int main()
{
	Person<string,int> p("测试用户",12);
	p.printf();
}

类外实现构造函数

template<class Name, class Age>
Person<Name,Age>::Person(Name nam, Age age)
{
	this->name = name;
	this->age = age;
}

类外实现成员函数

template<class Name, class Age>
void Person<Name, Age>::printf()
{
	std::cout << "name = " << this->name << "  age=" << this->age << std::endl;
}

类模板分文件编写

由于类模板中成员函数创建时机是在调用阶段，导致分文件编写时链接不到

解决方案：

直接包含整个.cpp源文件
将声明和实现写到同一个文件中，并更改后缀名为 .hpp ，.hpp是约定的名称，并不是强制

解决方案-包含整个源文件

我们提供三个文件：
Person.cpp Person.h Main.cpp
其各文件内容如下：

Person.cpp

#include "Person.h"

//类外实现构造函数
template<class Name, class Age>
Person<Name, Age>::Person(Name nam, Age age)
{
	this->name = name;
	this->age = age;
}

//类外实现成员函数
template<class Name, class Age>
void Person<Name, Age>::printf()
{
	std::cout << "name = " << this->name << "  age=" << this->age << std::endl;
}

Person.h

#pragma once
#include <iostream>
#include <string>
using namespace std;

template<class Name, class Age>
class Person
{
private:
	Name name;
	Age age;
public:
	Person(Name nam, Age age);
	void printf();
};

我们先定义函数主入口如下：
Main.cpp

#include <iostream>
#include <string>
using namespace std;
#include "Person.h"


int main()
{
	Person<string,int> p("测试用户",12);
	p.printf();
}

那么在该文件中，我们直接包含了 Person.h ，我们在编译时，编译器不会提示问题，但是当我们运行时，那么就会发现报错：
直接引用.h文件报错
这时候，我们将主函数入口 Main.cpp 修改为下面的内容：
Main.cpp

#include <iostream>
#include <string>
using namespace std;
#include "Person.cpp"


int main()
{
	Person<string,int> p("测试用户",12);
	p.printf();
}

再次编译运行，发现程序正常执行，那么也就是说我们可以通过包含整个类模板文件来实现以上需求

解决方案-将声明和实现写到同一个文件中，并更改后缀名为 `.hpp`

Person.hpp

#pragma once
#include <iostream>
#include <string>
using namespace std;

template<class Name, class Age>
class Person
{
private:
	Name name;
	Age age;
public:
	Person(Name nam, Age age);
	void printf();
};

//类外实现构造函数
template<class Name, class Age>
Person<Name, Age>::Person(Name nam, Age age)
{
	this->name = name;
	this->age = age;
}

//类外实现成员函数
template<class Name, class Age>
void Person<Name, Age>::printf()
{
	std::cout << "name = " << this->name << "  age=" << this->age << std::endl;
}

运行程序，也可以正常运行

类模板与友元

全局函数类内实现-直接在类内声明友元即可

Person.hpp

#pragma once
#include <iostream>
#include <string>
using namespace std;

template<class Name, class Age>
class Person
{
	//全局函数类内实现
	friend void print(Person<Name, Age> p)
	{
		p.printf();
	}
private:
	Name name;
	Age age;
public:
	Person(Name nam, Age age);
private:
	void printf();
};

//类外实现构造函数
template<class Name, class Age>
Person<Name, Age>::Person(Name nam, Age age)
{
	this->name = name;
	this->age = age;
}

//类外实现成员函数
template<class Name, class Age>
void Person<Name, Age>::printf()
{
	std::cout << "name = " << this->name << "  age=" << this->age << std::endl;
}

Main.cpp

#include <iostream>
#include <string>
using namespace std;
#include "Person.hpp"


int main()
{
	Person<string,int> p("测试用户",12);
	print(p);
}

运行结果：
程序运行结果

全局函数的类外实现-需要提前让编译器知道全局函数的存在

让全局函数的类外实现写到最前面

#pragma once
#include <iostream>
#include <string>
using namespace std;

//提前让编译器知道Person类的存在
template<class Name, class Age>
class Person;

//方法① 让全局函数的类外实现写到最前面
template<class Name, class Age>
void print(Person<Name, Age> p) {
	p.printf();
}

template<class Name, class Age>
class Person
{
	//全局函数类外实现 需要让编译器提前知道这个函数的存在
	friend void print<>(Person<Name, Age> p);
private:
	Name name;
	Age age;
public:
	Person(Name nam, Age age);
private:
	void printf();
};

//类外实现构造函数
template<class Name, class Age>
Person<Name, Age>::Person(Name nam, Age age)
{
	this->name = name;
	this->age = age;
}

//类外实现成员函数
template<class Name, class Age>
void Person<Name, Age>::printf()
{
	std::cout << "name = " << this->name << "  age=" << this->age << std::endl;
}