C++笔记---模板初阶

1. 初识模板

模板是什么

模板就是一种通用的模型，只要我们给出模板，编译器就可以自动帮助我们自动生成函数或类。

模板又分为函数模板和类模板。

模板的意义

我们在使用函数重载的过程中，常常会遇见下面的情况：

cpp 复制代码

void Swap(int& left, int& right)
{
    int temp = left;
    left = right;
    right = temp;
}
void Swap(double& left, double& right)
{
    double temp = left;
    left = right;
    right = temp;
}
void Swap(char& left, char& right)
{
    char temp = left;
    left = right;
    right = temp;
}

这些函数的函数体完全一样，而我们写了这么多个仅仅是因为参数的类型不同，如果有新的类型出现，我们还需要继续增添这样类似的函数。

增添这样的函数似乎并不难，因为他们简直像是一个模子刻出来的：

cpp 复制代码

void Swap(Type& left, Type& right)
{
    Type temp = left;
    left = right;
    right = temp;
}

这么简单的工作又何必让我们亲自动手呢？

祖师爷Bjarne Stroustrup说要方便，于是便有了模板。

2. 函数模板

用于生成函数的模板叫做函数模板，函数模板代表了一个函数家族，该函数模板与类型无关，在使用时被参数化，根据实参类型产生函数的特定类型版本。

使用格式

cpp 复制代码

template<class T1, class T2, ...... , class Tn>
返回类型 函数名(参数列表){}

template<typename T1, typename T2, ...... , typename Tn>
返回类型 函数名(参数列表){}

template是模板的关键字，后面的<>表示类型列表，里面的内容是类型的代号(可随意取名)。

紧接着下一行，就给出函数的模板。

例如刚才的Swap函数，我们可以利用函数模板给出：

cpp 复制代码

template<class Type>
void Swap(Type& left, Type& right)
{
    Type temp = left;
    left = right;
    right = temp;
}

实例化方式

函数模板归根到底只是一个用来给编译器生成函数的模板，它本身并不是函数。

编译器利用函数模板生成所需函数的过程叫做函数模板的实例化，实例化的方式有两种：

推导实例化：在调用函数时，编译器根据传入参数的类型推导出类型列表中的代号对应什么类型，进而实例化出函数以供调用。

显式实例化：在调用函数时，在函数名的后面利用<>给出参数列表的对应类型，以此实例化出函数以供调用。

cpp 复制代码

template<class T>
T Add(const T& left, const T& right)
{
	return left + right;
}

int main()
{
	int a = 10, b = 20;
	double c = 10.1, d = 20.2;

	// 推导实例化
    cout << Add(a, b) << endl;
    cout << Add(c, d) << endl;
    cout << Add(a, (int)d) << endl;
    cout << Add((double)a, d) << endl;

    // 显式实例化
    cout << Add<int>(a, b) << endl;
    cout << Add<double>(c, d) << endl;
    cout << Add<int>(a, d) << endl;
	
	return 0;
}

模板参数的匹配原则

一个非模板函数可以和一个同名的函数模板同时存在，而且该函数模板还可以被实例化为这个非模板函数。

cpp 复制代码

// 专门处理int的加法函数
int Add(int left, int right)
{
   return left + right;
}

// 通用加法函数
template<class T>
T Add(T left, T right)
{
    return left + right;
}

void Test()
{
    Add(1, 2);       // 与非模板函数匹配，编译器不需要特化
    Add<int>(1, 2);  // 调用编译器特化的Add版本
}

对于非模板函数和同名函数模板，如果其他条件都相同，在调动时会优先调用非模板函数而不会从该模板产生出一个实例。如果模板可以产生一个具有更好匹配的函数，那么将选择模板。

cpp 复制代码

// 专门处理int的加法函数
int Add(int left, int right)
{
    return left + right;
}

// 通用加法函数
template<class T1, class T2>
T1 Add(T1 left, T2 right)
{
    return left + right;
}

void Test()
{
    Add(1, 2);     // 与非函数模板类型完全匹配，不需要函数模板实例化
    Add(1, 2.0);   // 模板函数可以生成更加匹配的版本，编译器根据实参生成更加匹配的Add函数
}

模板函数不允许自动类型转换，但普通函数可以进行自动类型转换。

3. 类模板

用于生成类的模板叫类模板。同理，这样的模板中某些类型待定，在被使用时必须显式进行实例化。

使用格式

cpp 复制代码

template<class T1, class T2, ..., class Tn> 
class 类模板名
{
    // 类内成员定义
};

例如栈类模板：

cpp 复制代码

#include<iostream>
using namespace std;
// 类模版
template<typename T>
class Stack
{
public:
	Stack(size_t capacity = 4)
	{
		_array = new T[capacity];
		_capacity = capacity;
		_size = 0;
	}
	void Push(const T& data)
    {
	    // 扩容
	    _array[_size] = data;
	    ++_size;
    }
private:
	T* _array;
	size_t _capacity;
	size_t _size;
};

int main()
{
	Stack<int> st1;    // int
	Stack<double> st2; // double
	return 0;
}

通过类模板给出的栈就可以支持存储各种类型的数据，而不需要依照不同的类型写多个栈。

实例化方式

类模板实例化与函数模板实例化不同，类模板实例化需要在类模板名字后跟<>，然后将实例化的类型放在<>中即可，类模板名字不是真正的类，而实例化的结果才是真正的类。

cpp 复制代码

// Stack是类名，Stack<int>才是类型
Stack<int> st1;    // int
Stack<double> st2; // double

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

cpp 复制代码

template<class T1, class T2, ..., class Tn> 
返回类型 类名<T1, T2, ..., Tn>::函数名(参数列表)
{
    // 函数体
}

如将Push函数放到Stack模板外定义：

cpp 复制代码

#include<iostream>
using namespace std;
// 类模版
template<typename T>
class Stack
{
public:
	Stack(size_t capacity = 4)
	{
		_array = new T[capacity];
		_capacity = capacity;
		_size = 0;
	}
	void Push(const T& data);
private:
	T* _array;
	size_t _capacity;
	size_t _size;
};

// 模版不建议声明和定义分离到两个文件.h 和.cpp会出现链接错误，具体原因后面会讲
template<class T>
void Stack<T>::Push(const T& data)
{
	// 扩容
	_array[_size] = data;
	++_size;
}

int main()
{
	Stack<int> st1;    // int
	Stack<double> st2; // double
	return 0;
}