C++模板初阶

泛型编程

假如我们要写一个两数交换的函数，按我们之前学的知识，我们会这样。

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;
}
int main()
{
	int a = 1, b = 2;
	//Swap(a, b);
	Swap(a, b);

	double c = 1.1, d = 2.22;
	//Swap(a, b);
	Swap(c, d);

	return 0;
}

这是函数重载，按我们的理解，再增加不同的类型的数进行交换又要写一个函数，这样就需要不断的去写函数。
所以这里就引出了我们接下来要说的泛型编程。

函数模板

格式

template<typename T>

template是关键字，
T是模板类型名称，可以随便给。

定义多个模板参数
template

上面交换的代码可以写成这样

template<class T>
void Swap(T& x, T& y)
{
	T tmp = x;
	x = y;
	y = tmp;
}
int main()
{
	int a = 1, b = 2;
	//Swap(a, b);
	Swap(a, b);

	double c = 1.1, d = 2.22;
	//Swap(c,d);
	Swap(c, d);

	return 0;
}

它是针对广泛的类型来进行编程的。T具体的类型是什么我也不知道。

写成这样，无论什么类型的数据进行交换都只需要写这一个模板。

模板调用的是同一个函数吗？

那现在问题来了，Swap(a, b);和Swap(c, d);调用的是同一个函数吗？
通过调试我们发现好像是这样，但是只看这个是不够的，还是看一下汇编，结果发现函数地址不一样，所以肯定不是同一个函数。

其实我们仔细想想也知道，不可能是同一个，同一个指令是一样的。那函数要建立栈帧，这两个栈帧大小一样吗？
要交换的数的类型不一样，函数栈帧的大小也肯定不一样。

模板的实现原理

那现在又有一个问题，上面两个swap函数调用的是不是模板？
其实不是，这么说吧！Swap(a, b);编译器会判断出a，b的类型是int，继而对模板进行一定的推演，判断出T的类型是int,然后根据模板实例化一个用int数据交换的函数。实际函数调用的不是模板，而是调用的是模板生成的代码。

其实函数一点也没有减少，只是有了模板编译器帮我们生成了。

T不明确

下面看这段代码会报错吗？

T Add(const T& left, const T& right)
{
	return left + right;
}

int main()
{
	int a1 = 10;
	double d1 = 10.11;
	Add(a1, d1);
	return 0;
}

答案是会报错，这是因为模板再推演实例化的时候出现了歧义，他不知道T的类型是int还是double;

那怎么办呢？
很简单，强制类型转换。这是根据实参传递给形参，自动推演模板类型

Add(a1, (int)d1);
Add((double) a1, d1);

那除了强制类型转换还有没有别的方法呢？
显示实例化

 Add<int>(a1, d1)
 Add<double>(a1, d1)

模板实例化的函数和普通函数

int Add(int left, int right)
{
	return left + right;
}

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

请问能同时存在吗？
能！

那编译器会调用哪个函数？
编译器有个原则，调用谁的成本低就调用谁。很显然如果调用模板实例化的函数需要推演实例化这些东西，所以它会调用普通函数。

那如果非要调用模板实例化的函数呢？
显示实例化

编译器自己选择？
其实编译器非常聪明，它会调用跟它更加匹配的那个函数。

类模板

类模板就是定义一个模板参数，整个类里面都可以用。

那现在问题来了，之前学习的typedef不够用吗？
答案是不够，比如写一个栈，

typedef int STDateType;
class Stack
{
private:
	STDateType* _a;
	size_t _top;
	size_t _capacity;
};
int main()
{
	Stack st;
	return 0;
}

现在我栈上既要存储int又要存储double数据就办不到了！

类模板写法

template<class T>
class Stack
{
public:
	Stack(int capaicty = 4)
	{
		_a = new T[capaicty];
		_top = 0;
		_capacity = capaicty;
	}

	~Stack()
	{
		delete[] _a;
		_capacity = _top = 0;
	}

private:
	T* _a;
	size_t _top;
	size_t _capacity;
};

类模板用法

怎么用呢？必须得显示实例化。

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

注意事项

1.模板的名字不能直接表示类型，加上模板参数才能表示类型

vector <int> v1;

2.类里面如果声明和定义分离怎么写？

class Vector
{
	~Vector();
};
template<class T>
Vector<T>::~Vector()//不能只指定类名，得指定类型
{
	delete[] _pData;
	_pData = nullptr;
	_size = _capacity = 0;
}

3.类模板声明和定义一定要放在同一个文件。
如果声明和定义分离会出现链接错误。