引子

我们以前对于交换两个变量可能会根据其参数类型的不同写不同的函数，但是每个函数除去参数类型之外都是相同的
如

//交换两个变量
//c语言交换
void swapint(int *a,int *b)
{
   }

//c++
//c++可以重载
void swap(int & a,int& b)
{
   }
void swap(double& a,double&b)
{
   }

因此就造成了很大的冗余没有必要，所以就提出了模板的概念

模板

函数模板

模板和印刷术非常像普通情况下，如，要抄一首诗，1000编，让1000个人来抄，效率很低
我们就可以把诗词刻在一个模具上面，印刷出来1000份，非常的方便

template < class T>
也可以template < class T1，class T2……>

//函数模板
template<class T>//也可以这样template<typename T>，模板参数列表--参数的类型

//也可以定义多个类型
//template<class T1,class T2>

//无论有多少个函数类型，都用他就可以了，自定义类型也可以
void swap(T& a, T& b)//函数参数列表，参数对象，
{
   
	T x = a;
	a = b;
	b = x;
}
int main()
{
   
	int a = 0, b = 1;
	double c = 1.1, d = 2.0;
	//我们写函数交换
	swap(a, b);//调用的是实例化之后的函数，模板实例化	swap(d, c);
	char e = ' ', f = 'a';
	//很麻烦都是类似的，这些swap最大的不同再类型上面，只是单纯的类型不一样其他东西都是一样的，
	
	return 0;

}

template<class t>
t add(const t& a, const t& b)
{
   
	return a + b;
}


template<class T1,class T2,class T3>
T1 add(const T2& a, const T3& b)
{
   
	return a + b;
}


int main()
{
   
	int a = 1, b = 2;
	double c = 1.1, d = 2.3;
	cout << add(a, b) << endl;
	cout << add(c, d) << endl;
	//如果要对于a和d加,不可以直接弄
	//1.强制转
cout<<add((double)a, d)<<endl;//这些都是自己推
 
//2.显示实例化
cout << add<int>(a, d) << endl;//指定我们要实例化的类型，指定t用int类型
cout << add<double>(a, d) << endl;
cout << add(c, d) << endl;
	return 0;
}

类模板

//类的模板，语法也是类似的
template<class t1>



class Stack
{
   
private:
	int _top; 
	int _capacity;
	t1 * _a;
public:
	Stack(int capacity = 4)
		:_top(0)
		, _capacity(4)
	{
   
		_a = new t1[capacity];//对于*a的处理初始化非常方便
	}
	~Stack()
	{
   
		delete[] _a;
		_a = nullptr;
	}

	void Push(const t1& m);
};

template<class t1>

void Stack<t1>::Push(const t1& m)//要指定类模板
{
   

}

int main()
{
   
	//类模板不支持参数类型的推演，只支持显示实例化的指定
	Stack<int> st1(2);//存int
	Stack <double>st2(2);//存double
	Stack<int*>st3;
	Stack<char>st4;
	st1.Push(1);

	return 0;
}