c++顺序容器

        顺序容器是将单一类型元素聚集在一起，并根据位置来存储和访问这些元素的一种容器，该容器中的元素排列顺序与元素值无关，而是由元素添加到容器里的次序决定。标准库定义了三种顺序容器类型：vector、list和deque。在使用顺序容器前，我们需要包含下列三种头文件之一：#include <vector>、#include <list>和#include <deque>。

        容器元素的初始化：

                                                C<T> c;

                                                C c(c2);                                 //将一个元素初始化另一个元素的副本，要求：c和

                                                                                               c2必须具有相同的容器类型，并存放相同类型的

                                                                                               元素。

                                                C  c(b, e);                             //初始化一段元素的副本，b,e也可以是指针

                                                C c(n, t);                               //分配指定数目的元素

                                                C c(n);

        容器内元素的类型约束：

                                                元素类型必须支持赋值运算；

                                                元素类型的对象必须可以复制；

        容器定义的类型别名：

                                                size_type、iterator、const_iterator（只能用于读取，不能改变其值）、

                                                reverse_iterator、const_reverse_iterator、difference_type、

                                                value_type（元素类型）、reference（元素的左值类型）、

                                                const_reference

        迭代器：

                常用迭代器运算：*iter（返回左值）、iter->mem、++iter、iter++、--iter、iter--、iter1 == iter2、

                                             iter1 != iter2

                vector和deque类型迭代器支持的操作：iter + n、iter - n、 iter1 - iter2、>、>=、<、<=

                顺序迭代器与逆序迭代器：c.begin()、c.end()、c.rbegin()、c.rend();

        访问容器中的元素：

                                                c.back();                                          //返回元素的引用即：reference类型，等于

                                                                                                          *--c.end();

                                                c.front();                                          //*c.begin();

                                                c[n]、c.at(n);                                   //只是用与deque和vector，抛出

                                                                                                         out_of_range异常，

                                                                                                         不能用于添加元素

        在顺序容器中添加元素：

                                                c.push_back(t);                               //在容器尾部添加一个元素，所有顺序容器都

                                                                                                          支持该操作

                                                c.push_front(t);                                //只适合list和deque，返回值为void类型

                                                c.insert(p, t);                                    //在指定位置添加元素

                                                c.insert(p, n, t);                                //在指定位置添加n个相同的元素

                                                c.insert(p, b, e);                               //在指定位置（p所指元素的前面）插入一段

                                                                                                          元素

                                                c.insert(c.begin(), t);                        //vector在头插入元素的方法

        删除容器中的元素： 

                                                在删除元素前，必须在容器中查找要删除的元素，才能用erase操作，查找元素的

                                                最简单方法为：find操作，头文件为：algorithm，list<T>::iterator iter =

                                                find(c.begin(), c.end(), searchValue);

                                                c.erase(p);                                      //返回一个迭代器，指向后面的元素

                                                c.erase(b, e);

                                                c.clear();

                                                c.pop_back();

                                                c.pop_front();                                  //只适用于list和deque

        赋值操作：

                                               c1 = c2;                                             //删除容器中c1的所有元素，然后将c2复制给

                                                                                                          c1         

                                               c1.swap(c2);

                                               c.assign(b, e);                                   //重新设置c中的元素，b和e必须不是指向c中

                                                                                                          元素的

                                                                                                          迭代器

                                               c.assign(n, t);

        容器大小的操作：

                                                c.size();

                                                c.max_size();

                                                c.empty();

                                                c.resize(n);                                        //如果n < c.size()；则删除多余的元素，

                                                                                                           否则添加。

                                                c.resize(n, t);

        vector容器的自增长:       reserve(n)、capacity();

        容器的选用：

                                               vector                                               //要求随机访问元素

                                               deque                                               //要求随机访问元素并在容器的首部或尾部插

                                                                                                         入或删除元素

                                               list                                                     //在中间插入或删除元素