C++STL基础之模板

---

前言

熟悉现代面向对象编程语言的朋友肯定都听过泛型编程,那么什么是泛型编程,首先要了解泛型编程必须从模板了解.

---

一、模板是什么？

从根本上来说,模板是一种以C++为泛型编程提供的语法支持,为了解决软件危机,软件设计领域提出了一种面向对象(OO)设计思想,但其实泛型编程同样是一种解决软件危机的有效手段,所谓泛型就是指在一个方法上,具有多个不同种类的数据结构可对其进行操作.在C++中,模板可分为函数模板和类模板.

二、模板的使用

1.为什么要使用模板

在日常编程中,经常会用到一些实现原理相同,但参数类型不同的函数或类,在实现这一方法时,我们可能由于参数的不同实现出了几种甚至十几种方法,但这些方法实现原理却都基本相似(参考下列代码),所以为了解决这一问题,便提出的泛型编程的思想,而模板正是泛型编程的实现手段.

void Swap(int& left, int& right) {
 	int temp = left;
 	left = right;
 	right = temp; 
 }
void Swap(double& left, double& right) {
	double temp = left;
 	left = right;
 	right = temp; 
 }
void Swap(char& left, char& right) {
 	char temp = left;
 	left = right;
 	right = temp; 
 }
 ......

2.函数模板的使用方法

在之前的代码中,很容易发现存在的问题,那么如何用模板进行解决,代码如下（示例）：

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

template是模板的声明,大致意思就是声明了一个不需要关注类型的类型变量T(T在这里可以理解为一个变量,变量内容为一种类型),在Swap函数中传入两个参数,为T&类型的两个变量,函数内部定义了一个T类型的变量用于作为中间变量交换两个参数的内容,在使用时,调用Swap(a,b),可根据a,b两个参数类型对Swap进行具体的实例化,也可以认为是根据a,b的类型为类型变量T(这里这么叫只是为了便于理解)赋值,将T的类型实例化为a,b的类型,由于两个参数都是T类型的,所以a,b类型必须相同.

3.函数模板的本质

函数模板其实可以看做是一个框架,传入什么样的参数将决定实例化出什么样的函数,使用不同类型的参数时,可以看做是对模板的实例化,在实例化时可以分为显示实例化和隐式实例化,代码如下

template<class T> 
T Add(const T& left, const T& right) {
 	return left + right; 
 }
int main()
{
 	int a1 = 10, a2 = 20;
 	// 隐式实例化,编译器根据具体传入的参数类型进行推导函数模板实例化后的类型
 	Add(a1, a2);
 	//显示实例化,由 程序员手动输入,选择实例化类型,如果类型不匹配,编译器会进行强制转换,转换不成功则会报错
 	 Add<int>(a1, a2);
 	return 0; 
 }

4.函数模板的使用规则

1. 一个非模板函数可以和一个同名的函数模板同时存在，而且该函数模板还可以被实例化为这个非模板函数,而如果同时存在模板函数和非模板函数,那么根据参数的不同,编译器会首先调用不需要进行实例化的函数,如果没有匹配的非模板函数,则会调用模板函数进行实例化,例如:

template<class T> 
T Add(const T& left, const T& right) {
 	return left + right; 
 }
 int Add(const int& left, const int& right) {
 	return left + right; 
 }
int main()
{
 	int a1 = 10, a2 = 20;
 	double b1 = 10.0,b2 = 20.0;
 	//调用非模板函数
 	Add(a1, a2);
 	//调用模板函数进行实例化
 	 Add(b1,b2);
 	return 0; 
 }

2. 模板函数隐式实例化时不允许自动类型转换，但普通函数可以进行自动类型转换,

template<class T> 
T Add(const T& left, const T& right) {
 	return left + right; 
 }
 int Add(const int& left, const int& right) {
 	return left + right; 
 }
int main()
{
 	int a1 = 10, a2 = 20;
 	double b1 = 10.0,b2 = 20.0;
 	//调用非模板函数,进行类型转换
 	 Add(a1,b2);
 	return 0; 
 }

类模板

类模板与函数模板实现原理大体相同,类模板同样并非一个类,而是一个类的架构,根据参数实例化出不同的类,而不同于函数模板的是,类模板的实例化不能通过隐式实例化进行,使用过STL库的人都知道,类模板的实例化是在类名后加实例化的类型,使用方法例如:

template<class T>
class Vector
{ 
public :
 Vector(size_t capacity = 10)
 : _pData(new T[capacity])
 , _size(0)
 , _capacity(capacity)
 {}
 
 ~Vector();
 
 void PushBack(const T& data)；
 void PopBack()；
 // ...
 
 size_t Size() {return _size;}
 
 T& operator[](size_t pos)
 {
 assert(pos < _size);
 return _pData[pos];
 }
 
private:
 T* _pData;
 size_t _size;
 size_t _capacity;
};
Vector<int> s1;
Vector<double> s2;

三、模板注意事项

模板参数的分类

在之前使用过的模板参数都是一些较常用的模板参数,都通称为类型模板参数,还有一种参数为非类型模板参数,非类型模板参数的使用与宏定义有些类似,就是用一个常量作为类(函数)模板的一个参数，在类(函数)模板中可将该参数当成常量来使用。例如:

 // 定义一个模板类型的静态数组
 template<class T, size_t N = 10>
 class array
 {
 public:
 T& operator[](size_t index){
 	return _array[index];
 }
 const T& operator[](size_t index) const {
 	return _array[index];
 }
 
 size_t size() const {
 	return _size;
 }
 bool empty() const {
 	return 0 == _size;
 }
 
 private:
 T _array[N];
 size_t _size;
 }； 

上述代码中T为类型模板参数,N则为非类型模板参数,
此处需注意 : 浮点数、类对象以及字符串是不允许作为非类型模板参数的。

模板的特化

在使用模板过程中免不了有一些较为特殊的类型,实现时与其他类型实现原理不同,这个时候就需要用到模板的特化,也就是在原模板类的基础上,针对特殊类型所进行特殊化的实现方式.
函数模板的特化步骤：

1. 必须要先有一个基础的函数模板
2. 关键字template后面接一对空的尖括号<>
3. 函数名后跟一对尖括号，尖括号中指定需要特化的类型
4. 函数形参表: 必须要和模板函数的基础参数类型完全相同，如果不同编译器则会报错误。
   示例代码:

template<class T>
bool IsEqual(T& left, T& right) {
 	return left == right; 
}
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;
};
//偏特化
template <class T1>
class Data<T1, int> {
public:
 Data() {
 	cout<<"Data<T1, int>" <<endl;
 }
private:
 T1 _d1;
 int _d2;
};

注意:还有一种特殊的偏特化,是将模板类型特化为指针或引用,这种特化是限制了特化的类型,进行偏特化之后,只能特化一部分类型,此种特化即使将全部薄板参数都进行特化之后也是一种偏特化,因为这种特化只是进行了部分限制,并没有具体特化为某种类型.
示例代码:

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

分离编译

1. 什么是分离编译
   一个程序（项目）由若干个源文件共同实现，而每个源文件单独编译生成目标文件，最后将所有目标文件链
   接起来形成单一的可执行文件的过程称为分离编译.
2. 模板不支持分离编译
   在C++编译过程中,是以单个源文件为单位进行编译,如果在一个源文件中定义了一个模板函数,但未在当前文件中使用,则该模板并不会进行实例化,另一个源文件在要使用,由于引入头文件,则在编译期不会报错,但在链接时,由于模板未实例化,所以,在链接时,由于找不到该实例化后的函数,导致链接报错.

---

总结

模板的引入增加了代码的灵活性,解决了很多问题,但在模板的优点之上,同样具有很多缺点,在之后的使用中,可以慢慢发现,在这里不做过多总结.