函数/类模板

1.泛型编程:编写与类型无关的通用代码,是代码复用的一种手段,模板是泛型编程的基础

2.函数模板

(1)概念:函数模板代表了一个函数家族，该函数模板与类型无关,在使用时被参数化，根据实参类型产生函数的特定 类型版本.

 (2)函数模板格式 template 返回值类型 函数名(参数列表){}

//template<class T>
template<typename T>
void Swap(T& x1,T& x2)
{
	T tmp = x1;
	x1 = x2; 
	x2 = tmp;
}
//不同类型不能交换

(3)原理:在编译器编译阶段，对于模板函数的使用，编译器需要根据传入的实参类型来推演生成对应类型的函数以供调用.

(4)函数模板的优化: 

当一个int +double,模板参数列表只有一个T,编译器无法确定自己是int

还是double.有两种走法:1,用户自己来强制转化,2:使用显式实例化

a.隐式实例化：让编译器根据实参推演模板参数的实际类型

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);
	Add(a1, (int)d1);//1.使用用户强转
	return 0;
}

b.显式实例化：在函数名后的<>中指定模板参数的实际类型

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

(5)模板参数匹配原则

与非函数模板类型完全匹配,不需要函数模板实例化

模板函数可以生成更加匹配的版本,编译器根据实参生成更加匹配的Add函数

3.类模板

template<class T>
class vector
{
public:
	vector()
		:_a(nullptr)
		,_size(0)
		,_capacity(0)
	{}
	~vector()
	{
		delete[] _a;
		_a = nullptr;
		_size = _capacity = 0;
	}
	void push_back(const T& x)
	{
		if (_size == _capacity)
		{
			int newcapacity = _capacity == 0 ? 4 : _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;
	}
	T& operator[](size_t pos)
	{
		assert(pos < _size);
		return _a[pos];
	}
	size_t size()
	{
		return _size;
	}
private:
	T* _a;
	int _size;
	int _capacity;
};
//模板不支持分离编译,也就是声明在.h.定义在.cpp
//在类外定义
template<class T>
T& vector<T>::operator[](size_t pos)
{
	assert(pos < _size);
	return _a[pos];
}
template<class T>
size_t vector<T>:: size()
{
	return _size;
}
int main()
{
	vector<int> v1;
	v1.push_back(1);
	v1.push_back(2);
	v1.push_back(3);
	v1.push_back(4);
	vector<double> v2;
	v2.push_back(1.1);
	v2.push_back(2.2);
	v2.push_back(3.3);
	v2.push_back(4.4);

	//cout << v2[9] << endl;


	for (size_t  i = 0; i < v1.size(); ++i)
	{
		v1[i] *= 2;//读
	}
	for (size_t i = 0; i < v1.size(); ++i)
	{
		cout << v1[i] << endl;//写
	}
	return 0;

}