C++的模版初解

一.函数模版

1.函数的模版概念：

函数模版代表一个函数家族，该函数与模版类型无关，根据实参类型产生函数特定的特定类型模版

2.函数类型格式

template<typename 1,typename 2,typename 3,...typename n>

返回值类型 函数名（参数类型）

using namespace std;
template <typename T>
void swap(T& left,T& right)
{
	T temp =left;
	left=right;
	right=temp;
}

使用上面交换函数模版便可以随意的使用swap函数了，如下图所示

int main()
{
	int a=10;
	int b=8;
	swap(a,b);
	printf("%d\n%d\n",a,b);
	
	double c=10.2;
	double d=8.2;
	swap(c,d);
	printf("%f\n%f\n",c,d);

	return 0;	
}

这两个都是使用了swap函数，依旧能够正常运行

二.函数模版的实例化：

用不同类型的参数使用函数模版时，称为函数模版的实例化，函数模版实例化分为:隐式类型实例化和显示类型实例化

1.隐式类型实例化:   

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

#include<stdio.h>
using namespace std;
template <typename 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;
}

    该语句不能通过编译，因为在编译的期间，当编译器看到该实例化时，推演其第一个Add，使其T推演成int，
    但是模版参数列表中只有一个T，在看到第二个d1，其参数为double类型，但是前面已经固定T为int类型了
    所以编译器便会报错。
    因此我们有两种方式解决问题：1.用户自己来强制转化 2.使得函数实例化

2.显示类型实例化：

在函数名后的<>中指定模版参数的类型

#include<stdio.h>
using namespace std;
template <typename T>
T Add(const T&left,const T&right)
{
	return left+right;
}

int main()
{
	int a= 10;
	double b=20.0;
	//显示实例化
	Add<int>(a,b);
	return 0;
}

三.类模版

#include<stdio.h>
using namespace std;
template<class T1,class T2,class T3>
class 类模版名
{
	//类内成员定义
};
template<class T>
class vector
{
	public :
		vector(size_t capacity =10)
		: _pData(new T[capacity])
		, _size(0)
		, _capacity(capacity)
		{}
		~vector();
		void pushback(const T&data);
		void popback();
	//...
	size_t size(){return _size;}
	T& operator[](size_t pos)
	{
		assert(pos<_size);
		return _pData[pos];
	}
	private:
		T*_pData;
		size_t _size;
		size_t _capacity;
};

template<class T>
vector<T>::`vector()
{
	if(_pData)
	delete[]_pData;
	_size=_capacity=0;
}