【C++】模板（初识）：函数模板、类模板

         本篇主要介绍C++中的模板初阶的一些知识。模板分为函数模板和类模板，我们一个一个来看。

1.函数模板

1.1函数模板概念

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

1.2函数模板格式

template<class T1, class T2, ...>  (class/typename都行，<>里面是模板参数列表)

返回值类型 函数名(参数列表)

{}

关键字：template   class/typename(二者无区别，但是不能使用struct代替class)

比如我们现在要写一个两个数交换的函数 

//模板类型
template<class T>
void Swap(T& x, T& y)
{
	T tmp = x;
	x = y;
	y = tmp;
}

1.3 函数模板原理

我们在调用的时候就正常调用，编译器会帮助我们生成对应的函数。

int a = 1;
int b = 2;
cout << a << b << endl;
Swap(a, b);
cout << a << b << endl;

 函数模板是一个蓝图，它本身并不是函数，是编译器用使用方式产生的特定类型函数的模具。所以其实模板就是将本应该我们重复的事情交给编译器。

比如我们再交换double类型的试一下。

int a = 1, b = 2;
Swap(a, b);
double c = 1.1, d = 2.2;
Swap(c, d);

顺便说一句，C++其实提供了交换的函数，就是swap()，可以直接用。

当模板参数只有一个时，我们传参就必须传类型相同的，传不同类型的话这一个模板参数是不明确的，如果想传不同的就可以多加一个模板参数，如下

//两个模板参数T1,T2
template<typename T1, typename T2>
void Swap(T1& x, T2& y)
{
	T tmp = x;
	x = y;
	y = tmp;
}

int a = 1, b = 2;
Swap(a, b);
double c = 1.1, d = 2.2;
Swap(c, d); //可传相同类型 

Swap(a, c); //可传不同类型

记住！我们调用的不是模板，而是模板通过对参数类型的推理而生成的函数

这里其实就是一种泛型编程，泛型编程就是编写与类型无关的通用代码，是代码复用的一种手段，模板是泛型编程的基础。

1.4函数模板的实例化

用函数模板生成对应的函数，就是模板的实例化

//模板实例化
template<class T> 
T Add(const T& left, const T& right)
{
	return left + right;
}

前面我们说到过，如果只有一个模板参数，调用函数传参时，要传一样类型的参数，如果这里非要传不同类型的参数，就有下面几种解决方式：

int a = 1, b = 2;
double c = 1.1, d = 2.2;

第一种，强制类型转换。这种方法叫做推导实例化。 

Add(a, (int)c);    //都为int
Add((double)a, c); //都为double

这种方法就是让编译器自己去推导T的类型。

第二种，显示实例化。在函数名和参数中间加上<>，<>里面写类型。

//显式实例化
Add<int>(a, c);
Add<double>(a, c);

这里的意思就是，我们不通过模板自己推导得出参数类型，我们直接给定T的类型了。

第三种，定义多个模板参数。前面提到过。

template<class T1, class T2> 
T1 Add(const T1& left, const T2& right)//返回值类型想给什么就给什么
{
	return left + right;
}

如果想对这种有多个模板参数的显式实例化，也是在在<>里写类型，逗号分隔。

//显式实例化
Add<int, double>(a, c);
Add<double, int>(a, c);

有些地方必须要用显式实例化，比如下面这个代码。

template<class T>
T* func(int a)
{
	return new T[n];
}

int main()
{
	func(10);//错误示范

	return 0;
}

这里模板推导不出来T到底什么类型，所以必须显式实例化，比如说我们想要int类型的。

int main()
{
	int* p = func<int>(10);

	return 0;
}

1.5 模板参数的匹配原则

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

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

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

 2.类模板

2.1 类模板的定义格式

template<class T1, class T2, ..., class Tn> （也可以用typename）

class 类模板名

{

        //类内成员定义
}

 比如说我们写一个栈Stack的一部分。

template<class T>
class Stack
{
public:
	Stack(int n = 4) //构造
		:_arr(new T[n])
		,_size(0)
		,_capacity(n)
	{}

	~Stack() //析构
	{
		delete[] _arr;
		_arr = nullptr;
		_size = _capacity = 0;
	}

	void Push(const T& x)
	{}

private:
	T* _arr;
	int _size;
	int _capacity;
};

这里的Push压栈时，空间不够我们要扩容，扩容怎么写？

直接手动扩容，不用realloc那些函数了。 步骤如下。

void Push(const T& x)
{
	if (_size == _capacity)//当空间不够时
	{
		T* tmp = new T[_capacity * 2]; //手动扩容
		memcpy(tmp, _arr, sizeof(T) * _size); //原数据拷贝到新空间
		delet[] _arr; //释放旧空间
		_arr = tmp; //指向新空间
		_capacity *= 2; //更新空间大小数据
	}

	_arr[_size++] = x; //入栈

}

 

2.2 类模板的实例化

类模板实例化与函数模板实例化不同，类模板实例化需要在类模板名字后跟<>，然后将实例化的

类型放在<>中即可，类模板名字不是真正的类，而实例化的结果才是真正的类。

比如上面的Stack，模板在这里其实很像c语言中的typedef，但是C语言实现栈，一个栈只能实现一种数据的存放，模板就能实现不同类型的栈。

Stack<int> s1;    //int
Stack<double> s2; //double

类模板都是显式实例化，模板推导不出来T的类型。

Stack是类名，Stack<int>才是类型，给不同的模板实例化，就是不同的类型。

本篇分享就到这里，拜拜~