C++初阶--list容器

List的介绍及使用

list的介绍

list - C++ Reference (cplusplus.com)

1. list是可以在常数范围内在任意位置进行插入和删除的序列式容器，并且该容器可以前后双向迭代。
2. list的底层是双向链表结构，双向链表中每个元素存储在互不相关的独立节点中，在节点中通过指针指向其前一个元素和后一个元素。
3. list与forward_list非常相似：最主要的不同在于forward_list是单链表，只能朝前迭代，以让其更简单高效。
4. 与其他的序列容器相比（array，vector，deque），list通常在任意位置进行插入、移除元素的执行效率更好。
5. 与其他序列式容器相比，list和forward_list最大的缺陷是不支持任意位置的随机访问，比如：要访问list的第6个元素，必须从已知的位置迭代到 该位置，在这段位置上迭代需要线性的时间开销；list还需要一些额外的空间，以保存每个节点的相关联信息（对于存储类型较小元素的大list来说这可能是一个重要因素）

其实list说白了就是一个双向带头循环链表

list的使用

list的构造

构造函数	接口
list()	构造空的list
list(size_type n, const value_type& val = value_type())	构造的list中包含n个值为val的元素
list(const list& x)	拷贝构造函数
list(InputIterator first, InputIterator last)	用first、last区间中的元素构造list

#include<iostream>
#include<list>
using namespace std;
int main()
{
    list<int> l1;  // 调用无参构造函数创建list对象
    list<int> l2(4, 100); // 使用4个100创建并初始化list对象
    list<int> l3(l2.begin(), l2.end()); // 使用l2的迭代器创建并初始化l3对象
    
    list<int> l4(l3); // 使用l3拷贝构造出l4
    return 0;
}

list iterator的使用

函数声明	函数说明
begin()	返回第一个元素的迭代器
end()	返回最后一个元素的迭代器
rbegin()	返回第一个元素的reverse_iterator即是end的位置
rend()	返回最后一个元素下一个位置的reverse_iterator，即begin的位置

1. begin与end为正向迭代器，对迭代器执行++操作，迭代器向后移动
2. rbegin与rend为反向迭代器，对迭代器执行++操作，迭代器向前移动

#include<iostream>
#include<list>
using namespace std;
int main()
{
    int arr[] = {1,2,3,4,5,6,7};
    list<int> ls(arr, arr+sizeof(arr)/sizeof(arr[0])); // 通过迭代器构造一个list，原生指针就是迭代器
    list<int>::iterator it = ls.begin();
    list<int>::reverse_iterator rit = ls.rbegin();

    while(it != ls.end())
    {
        cout << *it << " ";
        ++it;
    }

    cout << endl;
    while(rit != ls.rend())
    {
        cout << *rit << " ";
        ++rit;
    }
    cout << endl;
    return 0;
}

list capacity

函数声明	接口说明
empty	检测list是否为空，时返回true，否则就返回false
size	返回list中有效节点的个数

list element access

函数声明	接口说明
front	返回list的第一个节点中值得引用
back	返回list的最后一个节点中值的引用

list modifiers

函数声明	接口说明
push_front	在list首元素前插入值为val的元素
pop_front	删除list中第一个元素
push_back	在list尾部插入值为val的元素
pop_back	删除list中最后一个元素
insert	在list position 位置中插入值为val的元素
erase	删除list position位置的元素
swap	交换两个list中的元素
clear	清空list中的有效元素

template<class T>
void printlist(list<T>& L)
{
    for(auto& e:L)
    {
        cout << e << " ";
    }
    cout << endl;
}

int main()
{
    // 默认构造函数
    list<int> ls1;
    // 使用一个int数构造
    list<int> ls2(4,100);
    // 使用迭代器gouzao
    list<int> ls3(ls2.begin(), ls2.end());

    int arr[] = {1,2,3,4,5};
    list<int> ls4(arr, arr+sizeof(arr)/sizeof(arr[0]));

    // 在list的尾部插入4， 头部插入0
    ls4.push_front(4);
    ls4.push_back(0);
    printlist(ls4);

    // 删除list尾部节点和头部节点
    ls4.pop_back();
    ls4.pop_front();
    printlist(ls4);

    // 获取链表中第二个节点
    list<int>::iterator pos = ++ls4.begin();
    cout << *pos << endl;

    // 在pos前插入值为100的数
    ls4.insert(pos, 100);
    printlist(ls4);

    // 在pos位置前插入5个值为5的元素
    ls4.insert(pos, 5, 5);
    printlist(ls4);

    // 在pos前插入某个迭代区间中的元素
    vector<int> v(5, 102);
    
    ls4.insert(pos, v.begin(), v.end());
    printlist(ls4);

    // 删除pos位置上的元素
    ls4.erase(pos);
    printlist(ls4);

    // 删除list中[begin, end)区间的元素，即删除list中的所有元素
    ls4.erase(ls4.begin(), ls4.end());
    printlist(ls4);
    return 0;
}

list的迭代器失效

之前说过，此处可以将迭代器暂时理解成类似于指针，迭代器失效即迭代器所指向的节点无效，即该节点被删除了。因为list的底层结构为带头结点的双向循环链表，因此在list中进程插入时是不会导致list的迭代器失效的，只有在删除时才会失效，并且失效的只是指向被删除结点的迭代器，其他迭代器不会受到影响。

void TestListIterator()
{
    int arr[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 0};
    list<int> l(array, array+sizeof(array)/sizeof(array[0]));
    auto it = l.begin();
    while(it != l.end())
    {
        // erase()函数执行后，it所指向的结点已经被删除，因此it无效，在下一次使用it时，必须先给其赋值
        l.erase(it);
        ++it;
    }
}

将上面的代码改一下

int main()
{
     int arr[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 0};
    list<int> l(array, array+sizeof(array)/sizeof(array[0]));
    auto it = l.begin();
    while(it != l.end())
    {
        l.erase(it++);  // it = l.erase(it);
    }
    return 0;
}

模拟实现list

模拟实现的list源代码