C++中的模板函数和模板类

模板是 C++ 中的泛型编程的基础，编写与类型无关的通用代码，是代码复用的一种手段。 作为强类型语言，C++ 要求所有变量都具有特定类型，由程序员显式声明或编译器推导。 但是，许多数据结构和算法无论在哪种类型上操作，看起来都是相同的。 使用模板可以定义类或函数的操作，并让用户指定这些操作应处理的具体类型。

目录

1.函数模板

1.1模板函数的概念

1.2函数模板格式

1.3函数模板的原理

1.4函数模板的实例化

 2.类模板

2.1类模板定义格式

 2.2类模板的实例化

---

1.函数模板

1.1模板函数的概念

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

1.2函数模板格式

用关键字template来定义模板函数，也可以用class但是不能用struct代替class

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

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

{

函数体

}

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

模板参数列表可以类比函数参数列表，也可以用class但是不能用struct代替class

1.3函数模板的原理

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

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

1.4函数模板的实例化

用不同类型的参数使用函数模板时，称为函数模板的实例化。模板参数实例化分为：隐式类型转换和显示类型转换

1. 隐式类型转换：让编译器根据实参推演模板函数的实际类型
2. 显式实例化：在函数名后的<>中指定模板参数的实际类型

//text.cpp
#include<iostream>
using namespace std;
 
//用函数模板生成对应的函数->模板实例化
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);
 
/*该语句不能通过编译，因为在编译期间，当编译器看到该实例化时，需要推演其实参类型
  通过实参a1将T推演为·int ，通过实参d1将T推演为double类型，但模板参数列表中只有一个T
  编译器不知道此处确定为int 还是double而报错
*/
	//不同类型
	
	//推导实例化
	cout << Add((double)a1, d1) << endl;
//a2是int类型，d2是double类型，a2强转会进行隐式类型转换
	cout << Add(a1,(int ) d1) << endl;
	//a1是int类型，d1是double类型，d1强转会进行隐式类型转换
	// 
	//显示实例化
	cout<<Add<int>(a2, d2)<<endl;
	//d2显示转换称int类型
	cout << Add<double>(a2, d2) << endl;
	//a2显示转换称double类型
	return 0;
}

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

//text.cpp
#include<iostream>
using namespace std;
//相同类型相加模板函数
template<class T>
T Add(const T& left, const T& right)
{
	return left + right;
}
//不同类型相加模板函数
template<class T1,class T2>
T1 Add(const T1& left, const T2& right)
{
	return left + right;
}
//自定义Add函数
int Add(const int& x, const int& y)
{
	return x * y;
}
 
int main()
{
	int a1 = 10, a2 = 20;
	double d1 = 10.1, d2 = 20.2;
 
 
	cout<<Add(a1, a2)<<endl;
//优先调用现成的Add函数而不去模板实例化后在调用
 
	cout<<Add(d1, d2)<<endl;
	//走相同类型模板函数的实例化
	cout<<Add(d1, a2)<<endl;
	//走不同类型的模板实例化
 
	return 0;
}

 2.类模板

2.1类模板定义格式

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

class  类模板名

{
//类内成员定义
}

 2.2类模板的实例化

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

//Stack 是类名，Stack<int>才是类型

Stack<int> st1;   //int

Stack<int> st2;   //double

 

//text.cpp
#include<iostream>
using namespace std;
//相同类型相加模板函数
template<class T>
class Stack
{
public :
	Stack(int n = 4)
		:_array(new T[n])
		,_size(0)
		,_capacity(n)
	{}
 
	~Stack()
	{
		delete[]_array;
		_array = nullptr;
		_size = _capacity = 0;
	}
 
	void push(const T& x)
	{
		if (_size == _capacity)
		{
			T* tmp = new T[_capacity * 2]
				memcpy(tmp, _array, sizeof(T) * _size);
			delete[]_array;
			_array = tmp;
			_capacity *= 2;
}
		_array = [_size++] = x;
	}
private:
	T* _array;
	size_t _capacity;
	size_t _size;
 
};
 
 
int main()
{//类模板都是显示实例化
	Stack<int> st1;  //int
	st1.push(1);
	st1.push(2);
	st1.push(3);
 
 
	Stack<double> st2;  //double
	st2.push(1.1);
	st2.push(2.2);
	st2.push(3.3);
 
 
	return 0;
}

类模板中的函数声明与定义分离

//text.cpp
#include<iostream>
using namespace std;
 
template<class T>
class Stack
{
	//...
 
	void push(const T& x);
 
};
 
template<class T>
void Stack<T>::push(const T& x)
{
	if (_size == _capacity)
	{
		T* tmp = new T[_capacity * 2]
			memcpy(tmp, _array, sizeof(T) * _size);
		delete[] _array;
		_array = tmp;
		_capacity *= 2;
	}
	_array = [_size++] = x;
}
int main()
{
	return 0;
}