C++ 模板知识点

模板

引入
泛型编程：编写与类型无关的通用代码，是代码复用的一种手段。
我们知道在C++中可以通过重载实现相同函数名，形参类型不同来完成泛型编程。但是存在代码复用率较低，可维护性较差问题，编写了大量重复代码。
因此C++中通过引入模板来实现泛型编程。也就是说告诉编译器一个模子，让编译器根据传入实参的类型来生成相应的代码。

优点：
1 模板复用了代码，节省资源，更快的迭代开发，STL因此而生。
2.增强了代码的灵活性，无过多重复代码
缺点：
1.代码编译时间变长。
2. 出现错误不容定位。

模板分类

模板分为函数模板和类模板

函数模板

函数模板代表了一个函数家族，该函数模板与类型无关，在使用(传入实参)时被参数化，根据实参类型产生函数的特定类型版本。
格式
template<typename T1, typename T2,…,typename Tn>
返回值类型 函数名(参数列表){} typename可以换成class
原理
在编译器的编译阶段，对于函数模板的使用，编译器需要根据传入的实参类型来推演生成对应类型的函数以供调用。
实例化
用不同类型的参数使用函数模板时，成为函数模板的实例化。 也就是说是对模板函数传入不同的实参的时候。
分类
隐式实例化
让编译器根据传入的参数类型来推演模板参数的实际类型。

template<class 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); //可以的
	
	Add(d1, a2); //不可以，由于模板形参只有一个，而传入2个不同的类型，
	//编译器无法推断是那种类型。故错误
	//解决方法:1.用户强制转换2.显示实例化
	Add(a, (int)d);
	return 0;
}

显式实例化：在函数名后<>中指定模板参数的实际类型。这样也就固定了模板参数的实际类型，即使只有一个形参 ，传入不同类型的实参，此时编译器会自动强转转换。

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

模板参数的匹配原则
一个非模板函数可以和一个同名的函数模板同时存在，而且该函数模板还可以被实例化为这个非模板函数。
优先级
非模板函数>显式实例化模板函数>隐式实例化模板函数。
除非传入实参非模板函数无法匹配。

// 专门处理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版本
}

类模板

类模板的定义格式

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

// 注意：Vector不是具体的类，是编译器根据被实例化的类型生成具体类的模具
template<class T>
class Vector
{
public :
	Vector(size_t capacity = 10)
	: _pData(new T[capacity])
	, _size(0)
	, _capacity(capacity)
	{}
	// 使用析构函数演示：在类中声明，在类外定义。
	~Vector();

	private:
	T* _pData;
	size_t _size;
	size_t _capacity;
};
// 注意：类模板中函数放在类外进行定义时，需要加模板参数列表
template <class T>
Vector<T>::~Vector()
{
	if(_pData)
	delete[] _pData;
	_size = _capacity = 0;
}

类模板的实例化

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

// Vector类名不是真正的类，Vector<int>才是类型
	Vector<int> s1;
	Vector<double> s2;

** 非类型模板参数**

模板参数分类类型形参与非类型形参。
类型形参：出现在模板参数列表中，跟在class或者typename之类的参数类型名称。
非类型形参：就是用一个常量作为类(函数)模板的一个参数，在类(函数)模板中可将该参数当成常量来使用。
非类型的模板参数在编译期间就必须能确认结果。

模板特化

通常情况下，使用模板可以实现一些与类型无关的代码，但对于一些特殊类型的可能会得到一些错误的结果。

//此时需要特化，单纯T可能无法推演出类型。
//如:
template<class T>
bool IsEqual(T& left, T& right)
{
	return left == right;
}
void Test()
{
	char* p1 = "hello";
	char* p2 = "world";
	if(IsEqual(p1, p2))
		cout<<p1<<endl;
	else
		cout<<p2<<endl;
}

//特化版本
template<>
bool IsEqual<char*>(char*& left, char*& right)
{
	if(strcmp(left, right) > 0)
	return true;
	return false;
}
//此种建议不使用模板

类模板特化

全特化 ： 将模板参数列表中所有的参数都确定化。

template<class T1, class T2>
class Data
{
	public:
		Data() {cout<<"Data<T1, T2>" <<endl;}
	private:
		T1 _d1;
		T2 _d2;
};
template<>
class Data<int, char>
{
	public:
		Data() {cout<<"Data<int, char>" <<endl;}
	private:
		T1 _d1;
		T2 _d2;
};
void TestVector()
{
	Data<int, int> d1;
	Data<int, char> d2;
}

偏特化：
部分特化: 将模板参数类表中的一部分参数特化。
参数更进一步的限制：偏特化并不仅仅是指特化部分参数，而是针对模板参数更进一步的条件限制所设计出来的一个特化版本。

//两个参数偏特化为指针类型
template <typename T1, typename T2>
class Data <T1*, T2*>
{
	public:
		Data() {cout<<"Data<T1*, T2*>" <<endl;}
	private:
		T1 _d1;
		T2 _d2;
};

void test2 ()
{
	Data<int , double> d2; // 调用基础的模板
	Data<int *, int*> d3; // 调用特化的指针版本
}

模板分离编译

分离编译： 一个项目由若干个源文件共同实现，若干个源文件单独编译生成目标文件，最后将所有的目标文件链接起来形成单一的可执行文件的过程称为分类编译模式。
模板不建议分离编译
建议将声明和定义放到同一个 .hpp或者.h文件中。