C++ 序容器

    list<double> list; //保持double的list
    deque<double> deq;//保存double的deque
1
2

    vector<int> m_vec = {1,2,3,4,5,6,7,8,9};
    auto begin = m_vec.begin();
    //vector<int>::iterator beign = m_vec.begin(); //等价于auto begin的方式，使用了类型推导
    auto end = m_vec.end();
    while (begin != end)
    {
        cout << "current value:" << *begin<

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9

使用区间迭代器遍历打印vector中的元素。
例如：

   //通过list<string>定义一个迭代器类型
    list<string>::iterator iter;
    //通过vector<int>定义一个difference_type类型
    vector<int>::difference_type cout;
1
2
3
4

2.2，begin和end多版本类型

返回带r的版本返回反向迭代器，以c开头的版本则返回const迭代器
例如：

    list<string> a = {"Milton","Shakespeare","Austen"};

    auto it1 = a.begin();
    auto it2 = a.rbegin();

    auto it3 = a.cbegin();
    auto it4 = a.crbegin();
1
2
3
4
5
6
7

注：当不需要写访问时，应使用cbegin和cend

3，容器定义和初始化

 vector<int> v1; //默认构造函数
    vector<int> v2(v1);//以拷贝的方式使用v1的值给v2默认初始化
    vector<int> v3 = v2;//和v2的方式一样
    vector<int> v4{ 1,2,3,4,5 };
    vector<int> v5 = { 1,2,3,4,5 };//v4和v5等价
    vector<int> v6(v5.begin(), v5.end());
    vector<int> v7(8);//默认8个元素，都为默认值
    vector<int> v8(8, 1);//默认8个元素，默认值都为1
    auto v8_begin = v8.begin();
    auto v8_end = v8.end();
    while (v8_begin != v8_end)
    {
        cout << "v8 current value:" << *v8_begin << endl;
        v8_begin++;
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

注：在使用拷贝时，两个容器的类型及其元素类型必须匹配。
使用时，只有顺序容器的构造函数才接收大小参数，关联容器并不支持。

4，赋值和swap

赋值运算符，将左边容器中的全部元素替换为右边容器中的元素的拷贝。
例如：

    array<int,10> a1 = {0,1,2,3,4,5,6,7,8,9};
    array<int,10> a2 = a1;//将a2的内容替换为a1中元素的拷贝
    a2 = { 1,2,3 };//赋值后，a2的大小为3
1
2
3

使用时需要先导入array的头文件

4.1,容器赋值运算

 a1 = a2                将a1中元素替换为a2中元素的拷贝，a1和a2必须具有相同的类型
 a1 = {1,2,3,4,...}     将a1中元素替换为初始列表中元素的拷贝(array 不适用)
 swap(a1,a2)          交换a1和a2中的元素，a1和a2必须具备相同的类型， swap通常比从a1向a2拷贝快得多
a1.swap(a2)
assign操作不适用于关联容器和array
seq.assign(b,e)        将seq中的元素替换为迭代器b和e所表示的范围中的元素。迭代器b和e不能指向seq中的元素
seq.assign(il)           将seq中的元素替换为初始化il中的元素
seq.assign(n,t)         将seq中的元素替换为n个值为t的元素
1
2
3
4
5
6
7
8

注：顺序容器array除外，assign允许从一个不同但相容得类型赋值，或者从容器得一个子序列赋值。assign操作用参数所制定得元素替换左边容器中所有元素。
例如：

   list<string> list(1);
    list.assign(10, "Hello");//十个元素都是hello
1
2

4.2,swap

操作交换两个相同类型容器的内容，调用swap后，两个容器中的元素将会交换

    vector<string> v1(10);
    vector<string> v2(20);
    swap(v1, v2);
1
2
3

注：除了array外，交换两个容器的操作保证很快，元素本身并未交换，交换了两个人容器的内部数据结构

三，顺序容器操作

1，添加元素

除了array以外，所有标准容器都有灵活的内容管理，在运行是，可以动态添加或删除元素来改变容器大小。

注：
1）fordword_list有自己转悠版本的insert和emplace，不支持push_back和emplace_back
2）vector和string不支持push_front和emplace_front。
3）向一个vector，string或deque插入元素会使所有指向容器的迭代器，引用和指针失效。
向一个vector或string添加元素可能引起整个对象存储空间的重新分配，并将元素从旧的空间移动到新分配的内存空间中。
当用一个对象初始化容器时，或将一个对象插入到容器中时，实际上放入到容器中的是一个对象值得拷贝，而不是对象本身。

2，访问元素

每个顺序容器都有一个front函数，除forward_list之外所有顺序容器都有一个back函数，分别返回首元素和尾元素。
在使用之前需要检查容器内是否有元素，如果没有元素，则访问操作得结果是未定义得。
例如：

    vector<string> v1(10);
    if (!v1.empty())
    {
        auto vl1 = v1.front();
        auto vl2 = v1.back();//forward_list不支持
    }
1
2
3
4
5
6

顺序容器中访问元素的操作

at和下标操作只适合用于string，vector，deque和array
back不适用于forward_list；

3，删除元素

非array容器也有多种删除元素的方式，操作完成后会改变array容器的大小

注：
forward_list 有特殊的erase，不支持pop_back；vector和string 不支持pop_front。
在删除元素时，必须要做好检查，保证删除的元素是存在的。

4，forward_list操作

它是一个单向的链表，执行添加和删除元素的操作是通过改变给定元素之后的元素来完成。

例如：

    forward_list<int> flst = {0,1,2,3,4,5,6};

    auto prev = flst.before_begin();
    auto curr = flst.begin();

    while (curr != flst.end())
    {
        if (*curr % 2)
        {
            curr = flst.erase_after(prev);
        }
        else {
            prev = curr;
            ++curr;
        }
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

5，改变容器的大小

除了array不支持resize，可以使用resize来增大或缩小容器。如果当前大小大于所需要的大小，容器后部的元素会被删除；如果当前大小小于新大小，会将新元素添加到容器后部。
例如：

    list<int> ilist(10, 42);
    ilist.resize(15);//将5个为0的元素添加到ilist的末尾
    ilist.resize(25, -1);//将10个值为-1的元素添加到ilist的末尾
    ilist.resize(5);//从ilist末尾删除20个元素s

list.resize(n)               调整list的大小为n个元素，若n