模板

    写一些函数和类的时候，针对不同类型需要写很多重复的代码。

    函数：比如我们想要实现交换int，double，char等各种类型对象函数swap；

    类：比如我们想要实现一个数据结构栈stack，stack的多个对象 st1存储int，st2存储double等。

    在没有模板之前，我们需要针对各个类型写相对应的多个swap函数和stack类，而这些函数和类，逻辑是一样的，只是处理的对象类型不同。

• 泛型编程：使用模板，编写跟类型无关的代码。
• 模板的原理：编译器根据调用函数模板和类模板的类型，实例化出对应的函数和类。

• 函数模板概念：函数模板代表了一个函数家族，该函数模板与类型无关，在使用时被参数化，根据实参类型产生函数的特定类型版本。
• 函数模板格式

template<typename T1, typename T2, ..., typename Tn>
返回值类型  函数名（参数列表）{ }

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

Note：typename是用来定义模板参数关键字，也可以使用class(切记：不能使用struct代替class)

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

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

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，
	编译器无法确定此处到底该将T确定为int 或者 double类型而报错
	注意：在模板中，编译器一般不会进行类型转换操作，因为一旦转化出问题，编译器就需要背黑锅
	Add(a1, d1);    */
	// 此时有两种处理方式：
	//1. 用户自己来强制转化 2. 使用显式实例化    Add(a, (int)d); 
	return 0;
}

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

• 模板参数的匹配原则

1. 一个非模板函数可以和一个同名的函数模板同时存在，而且该函数模板还可以被实例化为这个非模板函数。
2. 对于非模板函数和同名函数模板，如果其他条件都相同，在调动时会优先调用非模板函数而不会从该模板产生一个实例。如果模板可以产生一个具有更好匹配的函数，那么选择模板。
3. 模板函数不允许自动类型转换，但普通函数可以进行自动类型转换。

   // 专门处理int的加法函数 
   int Add(int left, int right) 
   {
   	return left + right;
   }
   
   // 通用加法函数 
   template<class T>
   T Add(T left, T right) 
   {
   	return left + right; 
   }
   
   void Test()
   {
   	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 vector // 动态增长的数组
{
public:
	vector()
		:_a(nullptr)
		, _size(0)
		, _capacity(0)
	{}

	vector(size_t n)
		:_a(new T[n])
		, _size(0)
		, _capacity(n)
	{}

	~vector()
	{
		delete[] _a;
		_a = nullptr;
		_size = _capacity = 0;
	}

	// 类里面声明
	void push_back(const T& x);
	void pop_back();

	size_t size()
	{
		return _size;
	}

	T& operator[](size_t i)
	{
		assert(i < _size);
		return _a[i];
	}

private:
	T* _a;
	size_t _size;
	size_t _capacity;
};

// 类外面定义
template<class T>
void vector<T>::push_back(const T& x)
{
	// 如果空间不够，需要进行增容
	if (_size == _capacity)
	{
		size_t newcapacity = _capacity == 0 ? 2 : _capacity * 2;
		T* tmp = new T[newcapacity];
		if (_a)
		{
			memcpy(tmp, _a, sizeof(T)*_size);
			delete[] _a;
		}

		_a = tmp;

		_capacity = newcapacity;
	}

	_a[_size] = x;
	++_size;
}

template<class T>
void vector<T>::pop_back()
{
	assert(_size > 0);
	--_size;
}
int main()
{
	vector<int> v;
	v.push_back(1);
	v.push_back(2);
	v.push_back(3);
	v.push_back(4);

	for (size_t i = 0; i < v.size(); ++i)
	{
		// [] 写
		v[i] *= 2;
	}

	for (size_t i = 0; i < v.size(); ++i)
	{
		// [] 读
		cout << v[i] << " ";
	}
	cout << endl;

	return 0;
}

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

  //vector类名，vector<int>才是类型
  vector<int> s1;
  vector<double> s2;