C++ 学习（16）模板 - 函数模板 与 类模板

1、模板

C++的其中一种编程思想为泛型编程，主要利用的技术就模板，模板的特点：

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

 C++提供2种模板机制：函数模板和类模板

2、函数模板

2.1、基本语法

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

语法： 

template<typename T>

函数声明或定义

解释：

template    声明创建模板

typename  表示其后面的符号是一种数据类型，也可以用class代替，即 template<class T>

T               通用的数据类型，名称可以替换，通常为大写字母 

#include <iostream>
using namespace std;

//函数模板
template<typename T>
void mySwap(T& a, T& b)
{
	T tmp = a;
	a = b;
	b = tmp;
}

int main()
{
	int a = 5;
	int b = 8;

	cout << "交换前： a = " << a << "，b = " << b << endl;

	//1、自动类型推导
	mySwap(a, b);
	cout << "自动类型推导 - 交换后： a = " << a << "，b = " << b << endl;

	//2、显式指定类型
	mySwap<int>(a, b);
	cout << "显式指定类型 - 再次交换后： a = " << a << "，b = " << b << endl;

	system("pause");

	return 0;
}

 输出结果

交换前： a = 5，b = 8
自动类型推导 - 交换后： a = 8，b = 5
显式指定类型 - 再次交换后： a = 5，b = 8

2.2、注意事项

• 自动类型推导，必须推导出一致的数据类型T才可以使用
• 模板必须要确定出T的数据类型 ，才可以使用

#include <iostream>
using namespace std;

//函数模板
template<typename T>
void mySwap(T& a, T& b)
{
	T tmp = a;
	a = b;
	b = tmp;
}

//函数模板， 也可以使用calss代替typename
template<class T>
void f1()
{
	cout << "函数没有使用模板中的类型T" << endl;
}

int main()
{
	int a = 5;
	int b = 8;
	char c = 'a';

	//1、自动类型推导 - 必须推导出一致的数据类型T才可以使用
	mySwap(a, b);
	// mySwap(a, c);_//报错：没有与参数列表匹配的函数模板 mySwap 的实例参数类型为(int, char)


	//2、模板必须要确定出T的数据类型 ，才可以使用
	//f1();//报错：没有与参数列表匹配的函数模板 f1 的实例
	f1<int>();
	f1<char>();

	system("pause");

	return 0;
}

2.3、普通函数与函数模板区别

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

建议使用显式指定类型方式调用函数模板，因为自己可以确定通用类型T。

#include <iostream>
using namespace std;

//普通函数 - 两数相加
int add(int a, int b)
{
	return a + b;
}

//函数模板 - 两数相加
template<typename T>
T add2(T a, T b)
{
	return a + b;
}

int main()
{
	//函数模板 - 普通函数与函数模板区别
	int a = 1;
	char c = 'a';

	//普通函数调用 - 参数可以自动类型转换（隐式类型转换）
	cout << "普通函数调用，结果 = " << add(a, c) << endl;

	//函数模板调用 - 自动类型推导，不会发生隐式类型转换
	//add2(a, c); //报错：没有与参数列表匹配的函数模板add2实例参数类型为：(int,char)

	//函数模板调用 - 显式指定类型，可以发生隐式类型转换
	cout << "函数模板调用 - 显式指定类型，结果 = " << add2<int>(a, c) << endl;

	system("pause");

	return 0;
}

输出结果

普通函数调用，结果 = 98
函数模板调用 - 显式指定类型，结果 = 98 

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

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

如果提供了函数模板，最好就不要提供普通函数，否则容易出现二义性，实际开发中避免同时出现。

#include <iostream>
using namespace std;

//普通函数
void print(int a, int b)
{
	cout << "普通函数 - 参数 a = " << a << ", b = " << b << endl;
}

//函数模板
template<typename T>
void print(T a, T b)
{
	cout << "函数模板 - 参数 a = " << a << ", b = " << b << endl;
}

//函数模板重载
template<typename T>
void print(T a, T b, T c)
{
	cout << "函数模板重载 - 参数 a = " << a << ", b = " << b << ", c = " << c << endl;
}

int main()
{
	//函数模板 - 普通函数与函数模板调用规则 
	/*
		1、如果函数模板和普通函数都可以实现，优先调用普通函数
		2、可以通过空模板参数列表来强制调用函数模板
		3、函数模板也可以发生重载
		4、如果函数模板可以产生更好的匹配，优先调用函数模板
	*/
	int a = 1;
	int b = 8;
	//1、如果函数模板和普通函数都可以实现，优先调用普通函数
	print(a, b);

	//2、可以通过空模板参数列表来强制调用函数模板
	print<>(a, b);

	//3、函数模板也可以发生重载
	print(a, b, 20);

	//4、如果函数模板可以产生更好的匹配，优先调用函数模板
	print('a', 'c');


	system("pause");

	return 0;
}

输出结果

普通函数 - 参数 a = 1, b = 8
函数模板 - 参数 a = 1, b = 8
函数模板重载 - 参数 a = 1, b = 8, c = 20
函数模板 - 参数 a = a, b = c

2.5、模板的局限性

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

利用具体化的模板，可以解决自定义类型的通用化，具体化模板优先调用

学习模板并不是为了写模板，而是在STL能够运用系统提供的模板

#include <iostream>
using namespace std;

//函数模板 - 比较
template<typename T>
void compare(T& a, T& b)
{
	if (a == b)
	{
		cout << "相等" << endl;
	}
	else
	{
		cout << "不相等" << endl;
	}
}

class Person
{
public:
	string name;
	int age;

	Person(string _name, int _age): name(_name), age(_age){}
};

//如果想让类对象进行比较，需要利用具体化模板，具体化模板优先调用
template<> void compare(Person& p1, Person& p2)
{
	if (p1.name == p2.name && p1.age == p2.age)
	{
		cout << "相等" << endl;
	}
	else
	{
		cout << "不相等" << endl;
	}
}

int main()
{
	//函数模板 - 局限性
	//如果想让类对象进行比较，需要利用具体化模板
	Person p1("Tracy", 20);
	Person p2("Timo", 20);

	compare(p1, p2); //若没用具体化模板，编译时报错：二进制"==":"T"不定义该运算符到预定义运算符可接收的类型转换

	system("pause");

	return 0;
}

 输出结果 

不相等

3、类模板

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

3.1 基本语法

语法：

template<class T>

类

解释：

template  声明创建模板

class       表示其后面的符号是一种数据类型，也可以用typename代替

T             通用的数据类型，名称可以替换，通常为大写字母

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

//类模板
template<class NameType, class AgeType>
class Person
{
public:
	NameType name;
	AgeType age;

	Person(NameType _name, AgeType _age) : name(_name), age(_age) {}

	void print()
	{
		cout << "类模板成员属性值 name = " << name << ", age = " << age << endl;
	}
};

int main()
{
	//类模板 - 基本语法

	//类模板实例化对象 - 显式指定类型
	Person<string, int> p1("Tracy", 20);
	p1.print();

	system("pause");

	return 0;
}

输出结果

类模板成员属性值 name = Tracy, age = 20

3.2、类模板与函数模板区别

• 类模板没有自动类型推导，只能使用显式指定类型
• 类模板在模板参数列表中可以有默认参数 

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

//类模板
//类模板在模板参数列表中可以有默认参数 
template<class NameType, class AgeType = int>
class Person
{
public:
	NameType name;
	AgeType age;

	Person(NameType _name, AgeType _age): name(_name), age(_age) {}

	void print()
	{
		cout << "类模板成员属性值 name = " << name << ", age = " << age << endl;
	}
};

int main()
{
	//类模板 - 类模板与函数模板区别
	/*
		1、类模板没有自动类型推导，只能使用显式指定类型
		2、类模板在模板参数列表中可以有默认参数 
	*/

	//1、类模板没有自动类型推导，只能使用显式指定类型
	//Person p1("Tracy", 20); //没有自动类型推导，报错：缺少类模板 Person的参数列表
	Person<string, int> p2("Tracy", 20); //显式指定类型
	p2.print();

	//2、类模板在模板参数列表中可以有默认参数 
	Person<string> p3("Timo", 30);
	p3.print();

	system("pause");

	return 0;
}

输出结果

类模板成员属性值 name = Tracy, age = 20
类模板成员属性值 name = Timo, age = 30

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

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

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

//类模板
class Person1
{
public:
	void print1()
	{
		cout << "类模板中的成员函数" << endl;
	}
};

//普通类
class Person2
{
public:
	void print2()
	{
		cout << "普通类中的成员函数" << endl;
	}
};

//类模板 - 在调用成员函数时才会创建成员函数
template<class T>
class TestClass
{
public:
	T obj;

	//调用类模板中的成员函数
	void f1()
	{
		obj.print1();
	}

	//调用普通模板中的成员函数
	void f2()
	{
		obj.print2();
	}
};

int main()
{
	//类模板 - 类模板中成员函数创建时机：在调用成员函数时才创建
	TestClass<Person1> t1;
	t1.f1();
	//t1.f2();  //编译时报错：print2不是Person1<std::string>的成员

	TestClass<Person2> t2;
	//t2.f1();  //编译时报错：print不是Person2的成员
	t2.f2();

	system("pause");

	return 0;
}

输出结果

类模板中的成员函数
普通类中的成员函数

3.4、类模板对象作函数参数

类模板对象作函数参数有三种传入方式

1. 指定传入类型：直接显式对象的数据类型（建议使用）
2. 参数模板化，将对象中的参数变为模板进行传递
3. 整个类模板化：将这个对象类型模板化进行传递

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

//类模板
template<class NameType, class AgeType>
class Person
{
public:
	NameType name;
	AgeType age;

	Person(NameType _name, AgeType _age): name(_name), age(_age) {}

	void print()
	{
		cout << "类模板成员属性值 name = " << name << ", age = " << age << endl;
	}
};

//1、指定传入类型：直接显式对象的数据类型（建议使用）
void show1(Person<string, int>& p)
{
	p.print();
}

//2、参数模板化，将对象中的参数变为模板进行传递
template<typename T1, typename T2>
void show2(Person<T1, T2>& p)
{
	p.print();
	cout << "参数模板化，T1的类型 = " << typeid(T1).name() << endl;
	cout << "参数模板化，T2的类型 = " << typeid(T2).name() << endl;
}

//3、整个类模板化：将这个对象类型模板化进行传递
template<typename T>
void show3(T& p)
{
	p.print();
	cout << "整个类模板化，T的类型 = " << typeid(T).name() << endl;
}

int main()
{
	//类模板 - 类模板对象作函数参数
	/*
	* 三种方式：
		1、指定传入类型：直接显式对象的数据类型（建议使用）
		2、参数模板化，将对象中的参数变为模板进行传递
		3、整个类模板化：将这个对象类型模板化进行传递
	*/
	Person<string, int> p1("Tracy", 20);
	show1(p1);
	show2(p1);
	show3(p1);

	system("pause");

	return 0;
}

输出结果

类模板成员属性值 name = Tracy, age = 20
类模板成员属性值 name = Tracy, age = 20
参数模板化，T1的类型 = class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >
参数模板化，T2的类型 = int
类模板成员属性值 name = Tracy, age = 20
整个类模板化，T的类型 = class Person<class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >,int>

3.5、类模板与继承

当子类继承的父类是一个类模板时：

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

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

//类模板 - 父类
template<class NameType, class AgeType>
class Person
{
public:
	NameType name;
	AgeType age;
};

//子类 - 子类在声明的时候要指定出父类中T的类型
// 1、在父类后加指定类型
//class Sub : public Person  //不指定父类中T的类型，报错：缺少类模板Person的参数列表
class Sub : public Person<string, int>
{
};

//2、子类变为类模板
template<class T1, class T2, class T3>
class Sub2 : public Person<T1, T2>
{
public:
	T3 obj;

	Sub2()
	{
		cout << "T1的类型：" << typeid(T1).name() << endl;
		cout << "T2的类型：" << typeid(T2).name() << endl;
		cout << "T3的类型：" << typeid(T3).name() << endl;
	}
};


int main()
{
	//类模板 - 类模板与继承
	Sub s1;

	Sub2<string, int, char> s2;

	system("pause");

	return 0;
}

输出结果

T1的类型：class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >
T2的类型：int
T3的类型：char

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

类模板中成员函数类外实现时，需要加上模板参数列表

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

//类模板
template<class NameType, class AgeType>
class Person
{
public:
	NameType name;
	AgeType age;

	//构造函数
	Person(NameType _name, AgeType _age);

	//成员函数
	void print();
};

//构造函数类外实现
template<typename NameType, typename AgeType>
Person<NameType, AgeType>::Person(NameType _name, AgeType _age)
{
	name = _name;
	age = _age;
}

//成员函数类外实现
template<typename NameType, typename AgeType>
void Person<NameType, AgeType>::print()
{
	cout << "类模板成员属性值 name = " << name << ", age = " << age << endl;
}

int main()
{
	//类模板 - 类模板成员函数类外实现
	Person<string, int> p1("Tracy", 20);
	p1.print();

	system("pause");

	return 0;
}

输出结果

类模板成员属性值 name = Tracy, age = 20 

3.7、类模板分文件编写

问题：类模板中成员函数创建时机是在调用阶段，导致分文件编写时链接不到，程序会报错

解决（二种解决方案）

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

3.7.1、直接包含.cpp源文件

（1）创建头文件person.h

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

//类模板
template<class NameType, class AgeType>
class Person
{
public:
	NameType name;
	AgeType age;

	//构造函数
	Person(NameType _name, AgeType _age);

	//成员函数
	void print();
};

（2）创建源文件person.cpp

#include "person.h"

//构造函数类外实现
template<typename NameType, typename AgeType>
Person<NameType, AgeType>::Person(NameType _name, AgeType _age)
{
	name = _name;
	age = _age;
}

//成员函数类外实现
template<typename NameType, typename AgeType>
void Person<NameType, AgeType>::print()
{
	cout << "类模板成员属性值 name = " << name << ", age = " << age << endl;
}

 （3）主函数文件

#include <iostream>
#include <string>
using namespace std;
//直接包含.cpp源文件
#include "person.cpp"

int main()
{
	//类模板 - 类模板分文件编写 - 直接包含.cpp源文件
	Person<string, int> p1("Tracy", 20);
	p1.print();

	system("pause");

	return 0;
}

输出结果

类模板成员属性值 name = Tracy, age = 20

3.7.2、声明和实现写到同一个文件后缀名.hpp 

（1）创建头文件person.hpp

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

//类模板
template<class NameType, class AgeType>
class Person
{
public:
	NameType name;
	AgeType age;

	//构造函数
	Person(NameType _name, AgeType _age);

	//成员函数
	void print();
};

//构造函数类外实现
template<typename NameType, typename AgeType>
Person<NameType, AgeType>::Person(NameType _name, AgeType _age)
{
	name = _name;
	age = _age;
}

//成员函数类外实现
template<typename NameType, typename AgeType>
void Person<NameType, AgeType>::print()
{
	cout << "类模板成员属性值 name = " << name << ", age = " << age << endl;
}

（2）主函数

#include <iostream>
#include <string>
using namespace std;
//声明和实现写到同一个文件后缀名.hpp
#include "person.hpp"

int main()
{
	//类模板 - 类模板分文件编写 - 声明和实现写到同一个文件后缀名.hpp
	Person<string, int> p1("Tracy", 20);
	p1.print();

	system("pause");

	return 0;
}

输出结果

类模板成员属性值 name = Tracy, age = 20

3.8、类模板与友元

• 全局函数类内实现：直接在类内声明友元即可
• 全局函数类外实现：需要提前让编译器知道全局函数的存在，类内声明时需要空模板参数列表

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

//提前声明全局函数类外实现中使用到的类模板
template<class T1, class T2>
class Person;

//2、全局函数类外实现：需要提前让编译器知道全局函数的存在
template<class T1, class T2>
void print2(Person<T1, T2>& p)
{
	cout << "全局函数类外实现， name = " << p.name << ", age = " << p.age << endl;
}

//类模板
template<class T1, class T2>
class Person
{
	//1、全局函数类内实现：直接在类内声明友元即可
	friend void print1(Person<T1, T2>& p)
	{
		cout << "全局函数类内实现， name = " << p.name << ", age = " << p.age << endl;
	}

	//2、全局函数类内声明类外实现 - 需要使用空模板参数列表
	friend void print2<>(Person<T1, T2>& p);

private:
	T1 name;
	T2 age;

public:
	Person(T1 _name, T2 _age) : name(_name), age(_age) {}
};

int main()
{
	//类模板 - 类模板与友元
	/*
		1、全局函数类内实现：直接在类内声明友元即可
		2、全局函数类外实现：需要提前让编译器知道全局函数的存在
	*/	
	Person<string, int> p1("Tracy", 20);
	print1(p1);
	print2(p1);

	system("pause");

	return 0;
}

输出结果

全局函数类内实现， name = Tracy, age = 20
全局函数类外实现， name = Tracy, age = 20