函数模板、类模板初识

函数模板：类模板 和 函数模板

函数模板

template<typename T1，typename T2,...，typename Tn>  
返回值类型  函数名(参数列表) { }
template<class T1，class T2,...，class Tn>
返回值类型  函数名(参数列表) { }

1、使用函数重载索然可以实现同名函数不同的参数，但是还是有不好的地方：
重载的函数仅仅只是类型不同，代码的复用概率比较低。只要有新的类型出现时，就需要增加对应的函数代码的可维护性比较低，一个出错可能所有的重载出错
2、泛型编程：编写与类型无关的通用代码，是代码复用的一种手段。模板是泛型编程的基础。
3、模板：函数模板 和 类模板
4、函数模板：函数模板代表一个函数家族，该函数模板与类型无关，在使用时被参数化，根据参数类型生产特定函数类型版本
注意： typenames是用来定义模版参数关键字，也可以使用class（class 比较常用）

函数模板匹配原则：

• 一个非模板函数可以和一个同名的函数模板同时存在，而且该函数模板还可以被实例化为这个非模板函数

//专门处理int的加法非模板函数
int  add(int a,int b)
{
	return  a+b;
} 

//通用加法函数函数模板
template<class T>
T add(T a,T b)
{
	return left+right;
} 
int main()
{
	add(1,2);//与非函数模板匹配，编译器不需要特化 
	add<int>(1,2);//调用编译器特化add版本 
}

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

// 专门处理int的加法函数
int Add(int left, int right)
{
    return left + right;
}
// 通用加法函数
template<class T1, class T2>
T1 Add(T1 left, T2 right)
{
    return left + right;
}
void Test()
{
    Add(1, 2); // 与非函数模板类型完全匹配，不需要函数模板实例化 
    Add(1, 2.0); // 模板函数可以生成更加匹配的版本，编译器根据实参生成更加匹配的Add函数
}

注意： 模板函数不允许出现自动类型转换，但普通函数可以进行自动类型转换
函数模板实例化视图： ↓↓↓↓↓↓

类模板

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

写一个动态顺序表的类模板：

template<class T>
class vevtor
{
	public:
		vector<size_t capacity = 10>//构造函数 
		:_pdate(new T[capacity])
		,_size(0)
		,_capacity(capacity)
		{ }
		//使用析构函数演示：在类内面声明，在类外定义
		~vector();
		
		void pushback(const T& date)//尾插 
		{
			_pdate[_size++] = date;
		} 
		
		void popback()//尾删 
		{
			--_size;
		}
		
		size_t size()//求顺序表中元素个数 
		{
			return _size;
		}
		
		T& operator[](size_t pos)//重载[] 
		{
			assert(pos<_size);
			return _pdate[pos];
		}
		
	private:
		T* _pdate;
		size_t _size;
		size_t _capacity;	
}; 

注意： 类模板中函数放在类外进行定义时，需要加模版参数列表

template<class T>
vector<T> :: ~vector()
{
	if(_pdate)
	{
		delete[] _pdatee;
	}
}

注意： vector不是具体的类，是编译器根据实例化的类型生成具体的模具

类模板的实例化

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

vector<int> s1;
vector<double> s2;