c++之模版的语法和原理

C++模版的语法和原理

1.泛型编程

如何实现一个通用的交换函数呢？
第一种方法：使用函数重载实现

#include<ostream>
void swap(int& a, int& b)
{
	int temp = a;
	a = b;
	b = temp;
}
void swap(double& a, double& b)
{
	double temp = a;
	a = b;
	b = temp;
}

int main()
{
	int a = 1, b = 2;
	swap(a, b);
	double c = 1.1, d = 2.2;
	swap(c,d);
	return 0;
}

第二种方法：使用泛型编程
定义：编写与类型无关的通用代码，是代码复用的一种手段，模版是泛型编程的基础。

格式：template<typename T1...>{}
		 返回值类型 函数名 参数列表 {}
使用泛型编程重新再实现swap函数

template<typename T>
void swap(T& left, T& right)
{
	T temp = left;
	left = right;
	right = temp;
}
int main()
{
	int a = 1, b = 2;
	swap(a, b);
	double d1,d2;
	swap(d1,d2)
	return 0;
}

2.函数模版

**

1.初识函数模版

**
理解：函数模版代表一个函数家族，该函数模版与类型无关，使用的时候被参数化，根据参数的类型产生对应的类型。
格式：

template <typename T1...>{}
返回值类型 函数名 （参数列表）{}
实际上函数模版是一个蓝图，它本身不是函数，是编译器用使用方式产生特定具体类型函数的模具
因此其实函数模版就是将本来人做的事情交给了编译器。

> 在编译阶段，编译器根据传入的实参类型来推演生成对应类型的函数以供调用。如上图，当int类型使用函数模版的时候，编译器通过实参类型的推演，将T确定为int类型，然后产生一份专门处理int类型的代码。

2.函数模版的实例化
概念：用不同类型的参数使用函数模版时，称为函数模版的实例化。
模版参数实例化分为：隐式实例化和显式实例化

（1）隐式实例化：让编译器根据实参推演模版参数的实际类型

template<typename T>
T add(const T& left, const T& right)
{
	return left + right;
}
int main()
{
	int i = 10, j = 20;
	add(i, j);
	double a = 10.1, b = 10.2;
	add(a, b);
	add(i, a);//此语句不能通过编译，因为编译器无法进行类型推断
	//因为i为int，a为double，编译器无法进行推断
	//但是面对这种情况有两种处理方式：
	//1.进行强制转化，例如：add(i,(int)a);
	//2.进行显式实例化
	return 0;
}

（2）显式实例化：在函数名后面<>中指定模版参数的实际类型

template<typename T>
T add(const T& left, const T& right)
{
	return left + right;
}
int main()
{
	int i = 10, j = 20;
	add(i, j);
	double a = 10.1, b = 10.2;
	add(a, b);

	//显式实例化：直接指明类型
	add<int>(i, j);
	add<double>(a, b);
	add<int>(i, a);
	return 0;
}

（3）模板参数的匹配原则：1.一个非模板函数可以和一个同名的函数模板同时存在，而且该函数模板还可以被实例化为这个非模板函数。

//专门处理int的加法函数
int add(int left, int right)
{
	return left + right;
}

//通用加法函数
template<typename T>
T add(const T& left, const T& right)
{
	return left + right;
}
int main()
{
	add(1, 2);//非模版函数匹配
	add<int>(1, 2);//模版函数匹配
	return 0;

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

//专门处理int的加法函数
int add(int left, int right)
{
	return left + right;
}

//通用加法函数
template<typename T>
T add(const T& left, const T& right)
{
	return left + right;
}
int main()
{
	add(1, 2);//非模版函数匹配，不需要函数模版实例化
	add(1, 2.0);//函数模版可以生成更加匹配的版本，编译器根据实参生成更加匹配的函数。
	return 0;

}

3.模板函数不允许自动类型转换，但普通函数允许自动类型转化。

3.类模板

定义格式：
template <class T1...>
class 类模板名
{
...//类内成员定义
};

（1）类模板的实例化：类模版实例化与函数模版实例化不同，类模版实例化需要在类模板名字后面跟<>，然后将实例化的类型放在<>中即可，类模板名字不是真正的类哦，而实例化的结果才是真正的类。
例如：Vector s1;//实例化vector模板，int类型s1
Vector s2;//实例化vector模板，double类型为s2

template<class T>
class Vector
{
public:
	Vector(int capacity = 10)//使用初始化列表进行初始化，构造函数
		, _pData(new T[capacity])//使用new申请空间和初始化
		, _size(0)
		, _capacity(capacity);
	~Vector();//析构函数，在类中声明，在类外定义。
	T& operator[](int pos) //operator[] 重载
	{
		assert(pos < _size);
		return _pData[pos];
	}
	//除了读还可以修改，因为采用&。

private:
	T* _pData;
	int _size;
	int _capacity;

};

//模版不支持在声明.h，定义在.cpp，不支持分离编译。
template <class T>
Vector<T> ::~Vector()
{
	if (_pData)
	{
		delete[] _pData;
	}
	_size = _capacity = 0;
}