[C++学习笔记] 5. C++泛型编程 —— 模板template

5. C++泛型编程 —— 模板template

在本人完成的CPP项目DocAnalysis中使用到了泛型编程的思想，可以联系本文与项目与一起学习。

两种模板机制： 函数模板和 类模板

5.1 函数模板

5.1.1 语法

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

解释：

template — 声明创建模板

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

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

template<typename T>
void mySwap(T& a, T& b)
{
	T temp = a;
	a = b;
	b = temp;
}

5.1.2 函数模板使用

使用函数模板有两种方式：自动类型推导、显示指定类型

void test01()
{
	int a = 10;
	int b = 20;

	// 利用模板实现交换
	// 1、自动类型推导
	mySwap(a, b);

	// 2、显示指定类型
	mySwap<int>(a, b);
    
	cout << "a = " << a << endl;
	cout << "b = " << b << endl;
}

注意：

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

void test01()
{
	int a = 10;
	int b = 20;
	char c = 'c';

	mySwap(a, b); // 正确，可以推导出一致的T
	//mySwap(a, c); // 错误，推导不出一致的T类型
}

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

template<class T>
void func()
{
	cout << "func 调用" << endl;
}

void test02()
{
	//func(); //错误，模板不能独立使用，必须确定出T的类型
	func<int>(); //利用显示指定类型的方式，给T一个类型，才可以使用该模板
}

5.2 类模板

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

5.2.1 语法

template<typename T>
类

解释：

template — 声明创建模板

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

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

5.2.2 示例

template<class NameType, class AgeType> 
class Person
{
public:
	Person(NameType name, AgeType age)
	{
		this->mName = name;
		this->mAge = age;
	}
	void showPerson()
	{
		cout << "name: " << this->mName << " age: " << this->mAge << endl;
	}
public:
	NameType mName;
	AgeType mAge;
};

5.2.3 类模板与函数模板的区别

• 类模板没有自动类型推导的使用方式，只能用显示指定类型方式

• 类模板在模板参数列表中可以有默认参数

#include <string>
#include <iostream>
using namespace std;
// 类模板
template<class NameType, class AgeType = int> 
class Person
{
public:
	Person(NameType name, AgeType age)
	{
		this->mName = name;
		this->mAge = age;
	}
	void showPerson()
	{
		cout << "name: " << this->mName << " age: " << this->mAge << endl;
	}
public:
	NameType mName;
	AgeType mAge;
};

// 1、类模板没有自动类型推导的使用方式
void test01()
{
	// Person p("孙悟空", 1000); // 错误 类模板使用时候，不可以用自动类型推导
	Person <string ,int>p("孙悟空", 1000); // 必须使用显示指定类型的方式，使用类模板
	p.showPerson();
}

// 2、类模板在模板参数列表中可以有默认参数
void test02()
{
	Person <string> p("猪八戒", 999); //类模板中的模板参数列表 可以指定默认参数
	p.showPerson();
}

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

5.2.4 类模板对象做函数参数

三种传入方式：

1. 指定传入的类型 — 直接显示对象的数据类型
2. 参数模板化 — 将对象中的参数变为模板进行传递
3. 整个类模板化 — 将这个对象类型 模板化进行传递

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

// 2、参数模板化
template <class T1, class T2>
void printPerson2(Person<T1, T2>&p)
{
	p.showPerson();
	cout << "T1的类型为： " << typeid(T1).name() << endl;
	cout << "T2的类型为： " << typeid(T2).name() << endl;
}
void test02()
{
	Person <string, int >p("猪八戒", 90);
	printPerson2(p);
}

// 3、整个类模板化
template<class T>
void printPerson3(T & p)
{
	cout << "T的类型为： " << typeid(T).name() << endl;
	p.showPerson();

}
void test03()
{
	Person <string, int >p("唐僧", 30);
	printPerson3(p);
}

输出：

name: 孙悟空 age: 100
name: 猪八戒 age: 90
T1的类型为： NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE
T2的类型为： i
T的类型为： 6PersonINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEiE
name: 唐僧 age: 30

5.2.5 类模板与继承

当类模板碰到继承时，需要注意一下几点：

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

template<class T>
class Base
{
	T m;
};

//class Son:public Base  //错误，c++编译需要给子类分配内存，必须知道父类中T的类型才可以向下继承
class Son :public Base<int> //必须指定一个类型
{
};
void test01()
{
	Son c;
}

//类模板继承类模板 ,可以用T2指定父类中的T类型
template<class T1, class T2>
class Son2 :public Base<T2>
{
public:
	Son2()
	{
		cout << typeid(T1).name() << endl;
		cout << typeid(T2).name() << endl;
	}
};

void test02()
{
	Son2<int, char> child1;
}


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