C++学习-入门到精通【16】自定义模板的介绍

C++学习-入门到精通【16】自定义模板的介绍

前言

在前面的学习中我们使用了不少的标准库中预先封装好的模板化的容器和算法。函数模板和类模板使程序员可以非常方便地表示若干不同的相关（重载）的函数或者类，这样的函数被称为函数模板特化，而类被称为类模板特化。

这种产生函数和类的技术称为泛型程序设计。可以将函数模板和类模板比作一个棕子，而棕子内部可以有不同的馅料，虽然使用这个模板做出来的都是相同外形（功能相同），但是里面的口味却不同（操作对象不同）。

一、类模板

类模板也被称为参数化类型，因为它们需要一个或多个参数，来说明如何自定义一个用于产生类模板特化的通用类模板。只要定义了一个类模板，当需要一个特定的类模板特化时，我们可以非常简单得到该特化的类类型，编译器会写出类模板特化的源代码。举个例子，如果此时有一个Stack类模板，那么我们就可以使用该模板创建出许多不同的Stack类模板特化（例如，double类型的Stack、Date类型的Stack、Employee类型的Stack等等）。

注意，如果要使用用户的自定义类型来创建一个模板的特化，那么该自定义类型必须满足模板的要求。例如，模板中会使用 < 来比较两个对象的大小从而进行排序，如果自定义的类型中没有重载 < 运算符，那么此时将发生编译错误。

创建一个自定义类模板：Stack<T>

所有类模板的定义均以关键字template开始，后面是一对尖括号<>中的模板形参表。每个模板形参表示一种类型，它必须以可交换关键字typename或class开头。类型形参的作用是Stack元素类型的占位符。在模板定义中，类型形参的名字必须是唯一的。并不一定要使用T，任何标识符都可以。

在Stack<T>开头的类模板中，整个定义中的元素的类型都被泛化成T。在使用类模板创建一个对象时，类型形参会和一个特定的类型相关联。此时，编译器将生成一个类模板的副本，其中所有出现类型形参的地方都被这个特定的类型替换。

类模板另一个与普通类定义不同的地方在于，类模板的接口并没有与它的实现分离开来。（这是因为模板的替换工件是完全发生在编译阶段的，如果将定义和实现分离，那么使用该类模板以创建一个类模板特化的源文件是只能访问到这个类模板的定义的，但是这个模板是如何实现的该源文件是无法获取的，因为一个程序的源文件是在链接阶段才进行一系列的操作将它们链接成一个可执行程序的，在编译阶段时编译器就无法创建一个对应的类模板的副本）。

Stack.h

#pragma once
#include <deque>

// 创建一个类模板
template <class T>
class Stack
{
public:
	T& top()
	{
		return stack.front();
	}

	void push(const T& pushValue)
	{
		stack.push_front(pushValue);
	}

	void pop()
	{
		stack.pop_front();
	}

	bool isEmpty() const 
	{
		return stack.empty();
	}

	void size() const
	{
		stack.size();
	}
private:
	std::deque<T> stack;
};

类模板中定义的成员函数就是函数模板，但是它们在类模板体内定义时，不用在前面加上template关键字和模板形参。

在类模板的定义之外声明模板的成员函数

成员函数的定义可以出现在类模板的定义之外。如果要这样做的话，每个成员函数必须以关键字template开始，后面跟着与类模板一样的模板形列表。除此之外，成员函数还必须用类名和作用域分辨运算符进行限定。

例如，在类模板之外定义成员函数top：这里的inline不加也可以，加了也不会报错，

template <class T>
inline T& Stack<T>::top()
{
	return stack.front();
}

其中的Stack<T>::表明该函数是在Stack<T>的作用域中。可以看到在类模板的定义之外声明模板的成员函数比在模板体内声明要复杂不少，所以我们更倾向于在模板内部声明它的成员函数。

对类模板Stack<T>进行测试

test.cpp

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

int main()
{
	Stack<double> doubleStack; // 创建一个double类型的类模板特化
	const size_t doubleStackSize = 5;
	double doubleValue = 1.1;

	cout << "Pushing elements onto doubleStack\n";

	// 往栈内压入5个double类型的值
	for (size_t i = 0; i < doubleStackSize; ++i)
	{
		doubleStack.push(doubleValue);
		cout << doubleValue << ' ';
		doubleValue += 1.1;
	}

	cout << "\n\nPopping elements from doubleStack\n";

	// 将栈中元素全部弹出
	while (!doubleStack.isEmpty())
	{
		cout << doubleStack.top() << ' ';
		doubleStack.pop(); 
	}

	cout << "\nStack is empty, connot pop.\n";

	Stack<int> intStack;
	const size_t intStackSize = 10;
	int intValue = 1;

	cout << "\n\nPushing elements onto intStack\n";

	for (size_t i = 0; i < intStackSize; ++i)
	{
		intStack.push(intValue);
		cout << intValue++ << ' ';
	}

	cout << "\n\nPopping elements from intStack\n";

	while (!intStack.isEmpty())
	{
		cout << intStack.top() << ' ';
		intStack.pop();
	}

	cout << "\nStack is empty, cannot pop." << endl;
}

运行结果：

可以看到，在上面的程序中我们使用两条不同的语句就能创建两个功能相同但是操作对象不同的Stack对象，并且它们的行为也符合我们对栈的设计。

二、使用函数模板来操作类模板特化的对象

如果大家认真读过上面的示例代码一定会发现，关于doubleStack和IntStack的操作的代码几乎一模一样，所以这就又提供了一个使用函数模板的机会。

下面我们就定义了函数模板testStack来完成和上面程序中的main函数相同的任务。

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

// 创建一个函数模板来测试特化的Stack类模板
template<class T>
void testStack(
	Stack<T>& theStack,
	const T& value,
	const T& increment,
	size_t size,
	const string& stackName
)
{
	cout << "Pushing elements onto " << stackName << "\n";
	T pushValue = value;

	for (size_t i = 0; i < size; ++i)
	{
		theStack.push(pushValue);
		cout << pushValue << ' ';
		pushValue += increment;
	}

	cout << "\n\nPopping elements from " << stackName << "\n";

	// 将栈中元素全部弹出
	while (!theStack.isEmpty())
	{
		cout << theStack.top() << ' ';
		theStack.pop(); 
	}

	cout << "\nStack is empty, connot pop.\n";
}

int main()
{
	Stack<double> doubleStack;
	const size_t doubleStackSize = 5;
	testStack(doubleStack, 1.1, 1.1, doubleStackSize, "doubleStack");

	cout << "\n\n";

	Stack<int> intStack;
	const size_t intStackSize = 5;
	testStack(intStack, 1, 1, intStackSize, "intStack");
}

运行结果：

在上面程序中我们使用函数模板时，编译器会根据第一个实参所使用的类型来决定该特化的函数模板中的模板形参使用的是什么类型。

三、非类型形参

上面程序中的类模板Stack中只在它的模板声明中使用了一个类型形参。除此之外，还可以使用非类型模板形参（或非类型形参），它可以有默认的实参并作为常量处理。例如C++标准库的array类模板，它的模板声明的开始部分是：
template <class T, size_t N>，
因此，如下的声明array <double, 100> salesFigures;
创建了一个有100个double类型元素的类模板特化，然后使用这个模板特化实例化了对象salesFigures。所以上面的这个声明就是指定该array对象内部的内置数组的大小。

四、模板类型形参的默认实参

类型形参也可以指定它的默认类型实参。例如，C++标准库中的stack容器适配器类模板的开始部分为template<class T, class Container = deque<T> >
它指定了默认情况下，stack对象使用一个deque对象来保存stack对象的T类型的元素。以下的声明
stack<int> values;
就是创建了一个int类型的stack类模板特化，并使用它实例化了一个名为values的对象。这个stack对象的int类型的元素存储在一个deque<int>对象中。

默认类型形参与默认的函数参数一样，必须是模板参数列表中最靠右边的形参，有多个默认形参时，这些形参也必须是最靠右边的形参。

五、重载函数模板

函数模板与重载之间的关系非常密切，当重载的函数对不同类型的数据执行相同的操作时，这些重载的函数可以用更加紧凑、方便的函数模板来表示。之后，我们就可以通过使用不同的形参，让编译器自动生成不同的函数模板特化来处理相应的函数调用。从一个给定的函数模板生成的这些函数模板特化都具有相同的名字，因此编译器采用重载的方式来调用正确的对应函数。

同样的函数模板也可以被重载。例如可以提供多个函数模板，它们具有相同的函数名，但是函数的形参不同。而且，一个函数模板也可以被非模板函数进行重载，这些非模板函数也一定要与该模板函数具有相同的函数名和不同的形参。

重载函数的匹配过程

编译器在函数被调用时就要决定到底调用哪一个函数的匹配过程。首先编译器会查看也有的函数和函数模板，找到函数名和参数类型与这个函数调用一致的一个函数，或者生成一个函数名和参数类型与这个函数调用一致的函数模板特化。如果无法匹配，编译器发出一条错误信息。如果对这个函数调用有多个匹配情况，那么编译器试着确定最佳的匹配。如果最佳匹配超过1个，那么编译器就会认为本次调用具有二义性，将产生一个错误信息。