STL教程之容器--序列式容器（vector、list、deque）

STL标准库提供了基本序列容器vector、list、deque，同时还包括stack、queue、priority_queue 等3种适配器。本文主要介绍基本序列式容器vector、list、deque。

1、vector类模板

vector是定义在命名空间std内的模板，可以实现数据结构中队列、数组、堆栈的所有功能，其头文件是< vector>:

template >
class vector;

vector中的T可以是任意数据类型，Allocator是关于空间配置器设置的，用于定义内存模型，默认方式是C++标准库里的allocator，一般不做修改。vector的迭代器是随机迭代器。
vector的成员函数：
（1）元素访问函数

at（int n）                          /* 返回vector中第n个元素 ,会做下标检查，溢出则报错*/
front（）                            /* 返回vector中第1个元素 */
back（）                             /* 返回vector中最后1个元素 */

（2）迭代器相关函数

begin（）                                /* 指向vector中第1个元素 */
end（）                                  /* 指向vector中最后1个元素的下一个位置 */
rbegin（）                               /* 指向vector逆向迭代器的第1个元素 */
rend（）                                 /* 指向vector逆向迭代器的最后1个元素的下一个位置 */

（3）元素搜索及查找

template 
InputIterator find(InputIterator first,InputIterator last,const T& value);
/* 查找first到last范围内值为value的元素，注： InputIterator 表示迭代器*/
例如：find（myvec.begin(),myvec.end(),2）;/* 在vector对象myvec中查找值为2的元素*/

template 
InputIterator find(InputIterator first,InputIterator last,Predicate predicate );
/* 查找first到last范围内满足条件predicate 的元素，注： InputIterator 表示迭代器*/

（4）、插入元素

push_back（const T& x）                                      /* 将元素x插入到vector尾 */
iterator insert（iterator it,const T&x=T()）                 /* 将元素x插入到it位置前 */
iterator insert（iterator it,int size,const T&x）            /* 插入size个元素x到it位置 */
iterator insert（iterator it,iterator first，iterator last） /* 将first到last之间的元素插入到it位置前 */

（5）、删除元素

pop_back()            /* 从vector尾弹出一个元素 */
erase(iterator it)    /* 删除元素it*/		
clear()		      /* 将vector中元素清空 */				

（5）、对象交换

swap（vector）    /* 交换两个vector的元素 */

（6）、容器大小

reserver(int size); 			   /* 预先设置vector的长度为size */
size_type size( )const;                    /* 获取vector的当前长度 */
size_type capacity( )const;                /* 获取vector的当前不需要重配内存存储器长度 */
size_type max_size( )const;                /* 获取vector的最大长度 */
size_type resize( size_type n,T x=T() );   /* 重新设置vector的长度为n */
`

2、list类模板

list是由双向链表实现的，每个节点存储一个元素。list的优势在于任何位置执行插入和删除动作都非常迅速，因为改变的仅仅是链接而已，list类模板定义在命名空间（namespace）std中的，头文件为< list>，该类模板的声明形式:

template >
class list;

list中的T可以是任意数据类型，Allocator是关于空间配置器设置的，用于定义内存模型，默认方式是C++标准库里的allocator，一般不做修改。list的迭代器是双向迭代器
list和vector的主要区别有：

1. list不支持随机存取，不支持下标操作符和at（）函数
2. list的插入和删除都比vector要快很多
3. list没有提供容量、空间重新分配等操作函数，每个元素都有自己的内存

（1）list的定义和构造函数

list listname;                                       /* 定义一个空list */
list< T>listname(size);                                 /*  建一个含size 个的元素的list */
list< T>listname(size,n); 				/*  建一个含size 个的元素n的list */
list< T>listname(list2); 			        /*  用list2初始化list*/
list< T> listname(list2.begin(), list2.end());          /*  用list2的beigin位置到end位置的元素初始化list*/

（2）list的元素的赋值及读取

void push_front(const T& x);                            /* 将元素x放入到list的开始位置 */
void push_back(const T& x);                             /* 将元素x放入到list的结束位置 */
void pop_front();                                       /* 从list的开始位置弹出元素 */
void pop_back(const T& x);                              /* 从list的结束位置弹出元素 */
void assign（size_type n ,const T&x=T()）               /* 赋值size个元素x到list中 */
void assign（iterator it,iterator first，iterator last） /* 将first到last之间的元素插入list*/

（3）list的容量

size_type size( )const;                    /* 获取list的长度 */
size_type max_size( )const;                /* 获取list的最大长度 */
size_type resize( size_type n,T x=T() );   /* 重新设置list的长度为n */

（4）迭代器相关

begin（）                                  /* 指向list中第1个元素 */
end（）                                   /* 指向list中最后1个元素的下一个位置 */
rbegin（）                               /* 指向list逆向迭代器的第1个元素 */
rend（）                                 /* 指向list逆向迭代器的最后1个元素的下一个位置 */
back（）                                /* 返回list中最后1个元素 */
front（）                               /* 指向list中第1个元素 */

（5）元素插入函数

iterator insert（iterator it,const T& x=T() ）           /* 将元素x插入到it位置前 */
void insert（iterator it,size_type size,const T&x） /* 插入size个元素x到it位置 */
iterator insert（iterator it,iterator first，iterator last）/* 将first到last之间的元素插入到it位置前 */

（6）删除元素函数

erase( iterator it);  /* 删除元素it */
erase( iterator first，iterator last);  /* 删除first到last之间的元素 */

（7）排序函数

void sort();               /* 按照从小到大的顺序进行排序 ，默认升序*/
void sort(greater< T> pr);       /* 按照pr函数结果进行排序 */
/*例子：mylist.sort(std::greater()); list按照降序排序  */

（7）合并函数

void merge(list& x);               /* 将x合并到list尾位置 ，建议不使用*/
void splice(iterator it,list & x);  /* 将x合并到list的it位置 */
void splice(iterator it,list & x,iterator first); /* 将x的first元素合并到list的it位置 */
void splice(iterator it,list & x,iterator first,iterator last); /* 将x的first到last但不包含last的元素合并到list的it位置 */

（8）、删除元素

erase(iterator it)    /* 删除元素it*/		
clear()					 /* 将list中元素清空 */		
remove(const T& x)	/ * 将list中元素为x的全部删除 */			

（9）其他

unique( );    /* 删除相邻的重复元素，不相邻的重复元素不删除*/	
void reverse();/* 使list逆序 */	

3、deque类模板

deque原意为“double-ended queue”，即双端队列，容器deque采用的是动态数组来管理序列中的元素，提供对序列的随机访问功能，可以在deque的双端实现快速插入和删除操作，但对于中间元素的操作却是非常耗时耗力的，deque容器完成的是标准C++中队列的所有功能，定义在头文件< deque>内，deque的迭代器是随机迭代器。
容器deque和vector拥有几乎相同的操作接口，除了以下几点：

1. 存取元素时，deque相对于vector稍慢一些
2. deque的迭代器指针是智能型指针
3. deque不支持对容器的内存重新分配机制
4. deque的元素不使用时，会被释放
5. deque的迭代器属于随机存取迭代器

（1）deque的构造函数(同vector)

deque dequename;                                 /* 定义一个空deque*/
deque< T>dequename(size);                       /*  建一个含size 个的元素的deque*/
deque< T>dequename(size,n); 					 /*  建一个含size 个的元素n的deque*/
deque< T>dequename(deque2); 				 /*  用deque2初始化deque*/
deque< T> dequename(deque2.begin(), deque2.end());/*  用deque2的beigin位置到end位置的元素初始化deque*/

（2）成员函数
deque的成员函数与vector的成员函数几乎一致，只不过deque比vector多了两个从头操作容器的函数。

push_front(const T& x);   /* 将元素x插入到deque的头位置 */
pop_front();       /* 从deque的头位置弹出一个元素 */