C++容器

顺序容器：此处的顺序不是体现在元素的值的顺序，而是指的是元素加入容器时的位置顺序相对应的。
关联容器：关联容器中的元素是按照关键字来保存和访问的。也就是通过键去获得对应的值
迭代器范围：一个迭代器范围由一对迭代器表示，两个迭代器分别指向同一个容器中的首元素或者尾元素之后的位置。这两个迭代器分别叫做begin和end，它们标记了容器中元素的一个范围[begin,end)。

顺序容器

顺序容器类型	特点
vector	可变大小数组	支持快速随机访问。因为元素保存在连续的内存空间里	中间位置添加删除元素很慢。在尾部插入删除速度快。因为要移动插入/删除位置之后的所有元素
string	专用于保存字符(与vector相似)	支持随机访问	中间位置添加删除元素很慢。在尾部插入删除速度快
deque	双端队列	支持快速随机访问	在头尾位置插入/删除速度很快
list	双向链表	不支持随机访问。只支持双向顺序访问	在链表的任何位置插入和删除都很快
forward_list	单向链表	不支持随机访问。只支持单向顺序访问	在链表的任何位置插入和删除都很快
array	固定大小数组	支持快速随机访问	不能添加或删除元素

顺序容器类型别名	作用
iterator	此容器类型的迭代器类型
const_iterator	可以读取元素，但不能修改元素的迭代器类型
size_type	无符号整数类型，足够保存此容器类型最大可能容器的大小
defference_type	带符号整数类型，足够保存两个迭代器之间的距离
value_type	元素类型
reference	元素的左值类型，与value_type&含义相同
const_reference	元素的const左值类型，即const value_type&

构造函数	作用
C c	默认构造函数，构造空容器
C c1(c2)	构造c2的拷贝c1
C c(b,e)	构造c，将迭代器b和e指定的范围内的元素拷贝到c（array不支持）
C c{a,b,c…}	列表初始化c

（1）以vector来举个例子：

#include <iostream>
#include <vector>
using namespace std;
int main(){
    vector<int> vec1;               //默认初始化，vec1为空 
    for(int i = 1;i <= 10;i++){
        vec1.push_back(i);
    } 

    vector<int> vec2(vec1);         //使用vec1初始化vec2
    vector<int> vec3(vec1.begin(),vec1.end());
    vector<int> vec4(10);           //10个值为0的元素 
    vector<int> vec5(10,4);         //10个值为4的元素 

    cout << (vec1 == vec2) ? true : false;
    cout << "\n";
    cout << (vec1 == vec3) ? true : false;
    return 0;
}

控制台输出：

（2）以list来举个例子

#include <iostream>
#include <list>
using namespace std;
int main(){
    list<int> list1;                //创建一个空的list 
    list<int> list2(list1);         //使用list1初始化list2 
    list<int> list3(3);             //创建含有3个元素的list3 
    list<int> list4(10,5);          //创建10个元素为5的list4 
    list<int> list5(list1.begin(),list1.end()); //使用list1初始化list5,同list2 

    cout << ((list1 == list2) ? true : false) << endl; 
    return 0;
}

控制台输出：1

（3）特殊的array，具有固定大小。在定义array时，不仅要指定元素类型，还需要指定容器大小。

#include <iostream>
#include <array>
using namespace std;

int main(){
    array<int,10> a1;                           //10个默认初始化的int
    array<int,10> a2 = {0,1,2,3,4,5,6,7,8,9};   //列表初始化
    array<int,10> a3 = {42};                    //a3[0]是42，剩余元素为0 

    //a4 = {0};                                 //错误：不能将一个花括号列表赋予数组 
    return 0;
}

---

赋值与swap	作用
c1 = c2	将c1中的元素替换为c2中的元素
c1 = {a,b,c…}	将c1中的元素替换为列表中的元素，不适用于array
a.swap(b)	交换a和b的元素
swap(a,b)	与a.swap(b)等价

大小	作用
c.size()	c中元素的数目，不支持forward_list
c.max_size()	c可保存在最大元素数目
c.empty()	判断c中是否含有元素，有元素返回false，否则返回true

添加删除元素（不适用array）	作用
c.insert(args)	将args中的元素拷贝进c
c.emplace(inits)	适用inits构造c中的一个元素
c.erase(args)	删除args指定的元素
c.clear(args)	删除c中的所有元素，返回void

（1）vector容器

#include <iostream>
#include <vector>
using namespace std;
int main(){
    vector<int> vec1;               //默认初始化，vec1为空 
    vec1.push_back(1);              //从末尾插入一个元素             vector中元素：1 
    vec1.insert(vec1.end(),2,3);    //从vec1.end()位置插入2个3        vector中元素：1 3 3
    vec1.insert(vec1.begin(),2,4);  //从vec1.begin()位置插入2个4      vector中元素：4 4 1 3 3

    vec1.pop_back();                            //删除末尾元素        vector中元素：4 4 1 3 
    vec1.erase(vec1.begin(),vec1.begin()+2);    //删除vec1[0]-vec1[2]之间的元素，不包括vec1[2]

    int size = vec1.size();         //得到vector的大小 
    bool isEmpty = vec1.empty();    //判断vector是否为空  

    //使用迭代器遍历 
    vector<int>::iterator iter = vec1.begin(); 
    for(;iter != vec1.end();iter++){
        cout << *iter << " ";
    }           
    return 0;
}

（2）list容器
list中的erase的作用是，使作为参数的迭代器失效，并返回指向该迭代器的下一个参数的迭代器

#include <iostream>
#include <list>
using namespace std;

int main(){
    list<int> list1;                //创建一个空的list 
    list<int> list2(3);             //创建含有3个元素的list 

    list1.assign(list2.begin(),list2.end());    //分配值，3个值为0的元素      0 0 0
    list1.push_back(10);                        //末尾添加一个值               0 0 0 10
    list1.insert(list1.begin(),3,2);            //从指定位置插入3个值为2的元素  2 2 2 0 0 0 10
    list1.erase(list1.begin());                 //使指定位置的迭代器失效        2 2 0 0 0 10 

    list1.assign(list2.begin(),list2.end());    //分配值，会覆盖之前的所有值     0 0 0

    list1.pop_back();                           //删除末尾的值                    0 0  
    list1.clear();                              //清空list1的全部值
    list1.erase(list1.begin(),list1.end());     //删除元素 

    list1.front();      //返回第一个元素的引用
    list1.back();       //返回最后一个元素的引用
    list1.size();
    list1.sort();
    list1.unique();

    return 0;
}

反向容器的额外成员（不支持forward_list）	作用
reverse_iterator	按逆序寻址元素的迭代器
const_reverse_iterator	不能修改元素的逆序迭代器
c.rbegin(),c.rend()	返回指向c的尾元素和首元素之前位置的迭代器
c.crbegin(),c.crend()	返回const_reverse-iterator

（1）每个顺序容器都有一个front成员函数，返回首元素的引用。
（2）除了forward_list，其他的所有顺序容器都有一个back成员函数，返回尾元素的引用。
（3）forward_list不支持递减迭代器，即–操作
（4）at(n) 成员函数，返回下标为n的元素的引用。如果下标越界，则抛出out_of_range异常，只适用于string、vector、deque和array

获取迭代器	作用
c.begin(),c.end()	返回指向c的首元素和尾元素之后位置的迭代器
c.cbegin(),c.cend()	返回const_iterator

关系运算符	作用
==,!=	相等不等运算符
<,<=,>,>=	关系运算符（无序关联容器不支持）