C++中顺序容器vector/deque/list/forward_list/array/string相关操作梳理

容器构造函数

C<T>  c;	创建容器时，需要提供容器内部保存元素的类型。
C    c；	创建一个空容器。
C    c(n);	创建包含n个元素的容器。容器内的元素需具有默认构造函数，或者能进行初始化。
C    c(n,p);	创建包含n个值为p的元素。
C   c(c1.iter1,c1.iter2);	创建容器c,包含元素为c1的迭代器 [iter1,iter2)范围内的元素（注意左右开闭区间）。需要注意的是，c和c1可以是不同类型的元素。例如c1可能是list<int>，c可以是vector<int>，此时仍然可以用c1的迭代器来初始化c。
C    c(c2);	创建容器c，其为c2的拷贝。
C    c{a,b,c...};	创建容器c，以花括号中的值对其进行列表初始化。

vector容器

//构造函数
vector<int> v1;                             //v1为空
vecotr<int> v2(3);                          //v2元素为0 0 0
vector<int> v3(4,5);                        //v3元素为5 5 5 5
vector<int> v4(v3.begin(),v3.begin()+2);    //v5为拷贝v3的 [0,2)中的元素，5 5（不包括第v3[2]）
    list<char*> li={"hello","world"};
    vector<string> v4_(li.begin(),li.end());   //v4_内的元素为2个： "hello" "world"
vector<int> v5(v2);                         //v4为v2的拷贝，其值为0 0 0
vector<int> v6{1,2,3,4};                    //v6中的元素为 1 2 3 4


//赋值 
vector<int> v1;    //v1为空
vector<int> v2;    //v2为空
v1 = {1,2,3};      //v1内包含三个元素： 1，2，3
v2 = v1;           //v2内包含三个元素： 1，2，3
v2 = {4,5,6};      //v2内包含三个元素： 4 5 6

//赋值assign(arg)函数,赋值操作
v1.assign(3,4);                    //v1包含3个元素： 4 4 4
v1.assign(v2.begin(),v2.end());    //v1包含3个元素： 4 5 6
v1.assign({1,2,3});                //v1利用列表内容进行初始化，v1包含3个元素：1 2 3

//交换swap(a,b)函数,将两个容器a和b中所有元素交换
v1.swap(v2);        //v1和v2内的所有的元素交换。v1内包含三个元素：4 5 6，v2内包含三个元素：1 2 3
swap(v1,v2);        //和上面的v1.swap(v2)效果完全相同。统一使用swap(v1,v2),而不是成员函数的  
                    //v1.swap(v2)是一个好习惯

//向后添加元素push_back(arg)成员函数，在容器后面添加
//v1此时的元素为{1，2，3}
v1.push_back(4);    //v1 ： 1 2 3 4
//vector 不支持push_front()操作；

//向后添加元素emplace_back(arg)
v1.emplace_back(5)    //v1:1 2 3 4 5
/*emplace_back(arg)中arg必须为元素的构造函数，此例中即 5 是int的构造函数
例如person的构造函数为person alan("Alan",25);则见下述*/
vector<person> class10;
person Mike("Mike",14);
person Alice("Alice",15);
//向class 10 中添加同学元素时，可以用下述方法
class10.push_back(Mike);
class10.push_back(person("Bob",15));
class10.emplace_back("Alan",18);
class10.push_back("Tom",12);        //错误
class10.emplace_back(Alice);        //错误
//插入emplace(p,arg); 在迭代器p指向的元素之前插入一个元素
vector<int> v1{1,2,3};
v1.emplace(v1.begin(),10);        //v1: 10 1 2 3
//vector不支持emplace_front();操作


//插入insert(arg);返回指向的第一个插入元素的迭代器
vector<int> v2{4,5,6};
//c.insert(p,t);在p迭代器之前插入元素t，该函数返回指向t的迭代器
v1.insert(v1.begin(),5);       // v1: 5 10 1 2 3 
//c.insert(p,n,t);c在p迭代器之前插入n个t元素，返回指向第一个插入元素的迭代器
v1.insert(v1.begin(),2,1);     //返回指向begin的迭代器；v1：1 1 5 10 1 2 3
//c.insert(p,b,e); 在迭代器p之前插入迭代器[b,e)范围内的迭代器
v1.insert(v1.end(),v2.begin(),v2.end());         //v1：1 1 5 10 1 2 3 4 5 6         
//c.insert(p,li);在迭代器p之前插入列表li                                            
v2.insert(v2.begin(),{1,2,3});    //列表插入 v2：1 2 3 4 5 6


//删除操作pop_back();删除最后一个元素
vector<int> v1{1,2,3};            //v1:1 2 3
v1.pop_back();                    //v1: 1 2
//vector 不支持pop_front()操作；

//删除操作erase();返回指向最后一个被删除元素下一个元素的迭代器
vector<int> v1{1,2,3,4,5};        //v1: 1 2 3 4 5
//c.erase(p);删除迭代器p位置处的元素
v1.erase(v1.begin());             //v1:2 3 4 5
//c.erase(b,e);删除容器中[b,e)范围内的元素
v1.erase(v1.begin(),v1.begin()+2);    //v1: 4 5

//back();front();成员函数;
vector<int> v1{1,2,3,4,5};
int k = v1.front();                //k = 1
k = v1.back();                    //k = 5

//删除clear();清除容器c中的所有元素
v1.clear();                //v1:空

容器比较常用的成员函数如上，下表将各类顺序容器可以使用的成员函数进行了汇总，哪些成员函数可以调用，哪些不可以调用，例如vector容器就不支持push_front()操作。（这个表是我搬运的，原作者制作不易，感谢）

顺序容器-->                                                   操作	vector<int>	string	list<int>	forward_list<int>	deque<int>	array<int,10>
初始化
C c1(c2),c1=c2,c{a,b,c…},c={a,b,c…}	√	√	√	√	√	c1,c2等大小
C c(b,e)	√	√	√	√	√	X
C c(n),c(n,t) n个值为t的元素	√	√	√	√	√	X
赋值和swap
swap(c1,c2),c1.swap(c2)(比拷贝快)	√	√	√	√	√	√（慢）
C c.assign(b,e),c.assign(l),c.assign(n,t)	√	√	√	√	√	X
容器的大小
size()返回容器的大小	√	√	√	X	√	√
max_size()返回>=容器的容量值	√	√	√	√	√	√
empty(),size()=0返回true	√	√	√	√	√	√
添加元素						X
c.push_back(t)，c.emplace_back(args) 返回值为void	√	√	√	X	√	X
c.push_front(t),c.emplace_front(args) 返回值为void	X	X	√	√	√	X
c.insert(p,t),c.emplace(p,args),c.insert(p,n,t),c.insert(p,b,e),c,insert(p,l) 插入位置为p之前，返回为指向第一个插入元素的迭代器，若(b,e)或l为空，则返回p，(b,e)不能指向c	√ 尾部位置较快	√ 尾部位置较快	√ 都很快	X 有自己特有的函数	√ 在首尾之外的位置插入很耗时	X
访问元素（返回值都为引用）
c.back()返回c中尾元素的引用	√	√	√	X	√	√
c.front()返回c中首元素的引用	√	√	√	√	√	√
c[n],c.at(n)，	√	√	X	X	√	√
删除元素
c.pop_back()删除尾元素，返回void	√	√	√	X	√	X
c.pop_front()删除首元素，返回void	X	X	√	√	√	X
c.erase(p),c.erase(b,e)，返回最后一个被删除的元素的下一个位置	√	√	√	X(有自己的版本)	√	X
c.clear()，删除所有元素，返回void	√	√	√	√	√	X
改变容器大小resize,若容器缩小迭代器，引用和指针失效
c.resize(n),c.resize(n,t) 大小n,值为t	√	√	√	√	√	X
c.shrink_to_fit()设置capacity()=size()	√	√	X	X	√	X
c.capacity(),不重新分配内存保存元素数；c.reserve(n),分配至少能容纳n个元素的内存	√	√	X	X	X	X

//未完待续，后续归纳forward_list容器的特殊成员函数。今儿个没时间码字了。