【C++】模板初阶

一、函数模板

【函数模板格式】

template<typename T1, typename T2,......,typename Tn>

例子：

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

int main()
{
	int a = 1, b = 2;
	double c = 1.1, d = 1.2;
	Swap(a,b);
	Swap(c, d);
	return 0;
}

注意：typename是用来定义模板参数关键字，也可以使用class

【函数模板的原理】

当调试的时候在模板层，但是底层依旧是调用Swap<int>，Swap<double>,不是Swap<T>

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

在编译器编译阶段，对于模板函数的使用，**编译器需要根据传入的实参类型来推演生成对应类型的函数以供调用。**比如：当用double类型使用函数模板时，编译器通过对实参类型的推演，将T确定为double类型，然后产生一份专门处理double类型的代码，对于字符类型也是如此。

1.1 函数模板的实例化

用不同类型的参数使用函数模板 时，称为函数模板的实例化。

模板参数实例化分为：隐式实例化和显式实例化。

【隐式实例化】

让编译器根据实参推演模板参数的实际类型

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

int main()
{
	int a1 = 10, a2 = 20;
	double d1 = 10.0, d2 = 20.0;
	Add(a1, a2);
	Add(d1, d2);
	return 0;
}

	//如果想使用模板，且传递的是不同类型的变量
	//1.强制类型转换
	//2.显示实例化
	cout << Add((double)a1,d1) << endl;
	cout << Add(a1,(int)d1) << endl;

【显示实例化】

在函数名后的<>中指定模板参数的实际类型

	cout << Add<int>(a1, d1) << endl;
	cout << Add<double>(a2, d1) << endl;

还能这么玩

template<typename T1,typename T2>
auto Add(const T1& left, const T2& right)
{
	return left + right;
}//用了auto让他推算类型
int main()
{
	int a1 = 10, a2 = 20;
	double d1 = 10.3, d2 = 20.4;

	// 显示实例化，不再让你去推演参数
	cout << Add<double,int>(a1, d1) << endl;
	cout << Add<int,int>(a1, d1) << endl;
	return 0;
}

无法推演出类型时，使用实例化，例如

template<typename T>
T* func(int a)
{
	T* p = (T*)operator new(sizeof(T));
	new(p)T(a);
	return p;
}
int main()
{
	func<int>(1);
	return 0;
}

1.2 模板参数的匹配原则

int Add(const int& left, const int& right)
{
	cout << "int Add(const int& left, const int& right)" << endl;
	return left + right;
}
template<typename T>
T Add(const T& left, const T& right)
{
	cout << "T Add(const T& left, const T& right)" << endl;
	return left + right;
}
template<typename T1,typename T2>
auto Add(const T1& left, const T2& right)
{
	cout << "auto Add(const T1& left, const T2& right)" << endl;
	return left + right;
}
//优先匹配  普通函数+参数匹配
//其次匹配  参数匹配+函数模板
//最后      类型转换一下也能用
int main()
{
	Add(1, 2);
	Add(1.1, 2.1);
	Add(1, 2.2);
	int a = 10;
	double b = 10.1;
	Add(a, (int)b);
	Add(a, b);
	return 0;
}

二、类模板

【类模板的定义格式】

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

template<typename T>
class Stack
{
public:
	Stack(size_t capacity = 4)
	{
		_array = (T*)malloc(sizeof(T) * capacity);
		if (nullptr == _array)
		{
			perror("malloc申请空间失败");
			return;
		}
		_capacity = capacity;
		_size = 0;
	}

	void Push(const T& data);
private:
	T* _array;
	size_t _capacity;
	size_t _size;
};

声明和定义分离，我们如何定义呢？

template<typename T>
void Stack<T>::Push(const T& data)
{
	_array[_size] = data;
	++_size;
}

模板不建议声明和定义分离到.h和.cpp会出现链接错误，具体后面会写

int main()
{
	Stack<int> st1; //类的对象类型int
	Stack<double> st1; //类的对象类型double
	return 0;
}