【C++语言】list的构造函数与迭代器

1. list****的介绍及使用

1.1 list****的介绍

list的文档介绍

1. list是可以在常数范围内在任意位置进行插入和删除的序列式容器，并且该容器可以前后双向迭代。

2. list的底层是双向链表结构，双向链表中每个元素存储在互不相关的独立节点中，在节点中通过指针指向其前一个元素和后一个元素。

3. list与forward_list非常相似：最主要的不同在于forward_list是单链表，只能朝前迭代，已让其更简单高效。

4. 与其他的序列式容器相比(array，vector，deque)，list通常在任意位置进行插入、移除元素的执行效率更好。

5. 与其他序列式容器相比，list和forward_list最大的缺陷是不支持任意位置的随机访问，比如：要访问list的第6个元素，必须从已知的位置(比如头部或者尾部)迭代到该位置，在这段位置上迭代需要线性的时间开销；list还需要一些额外的空间，以保存每个节点的相关联信息(对于存储类型较小元素的大list来说这可能是一个重要的因素)
   

1.2 list****的使用

list中的接口比较多，此处类似，只需要掌握如何正确的使用，然后再去深入研究背后的原理，已达到可扩展的能力。以下为list中一些常见的重要接口

1.2.1 list的构造

1）list (size_type n, const value_type& val = value_type())

list类提供了一个构造函数 list (size_type n, const value_type& val = value_type())，用于创建一个包含指定数量的元素的链表。

n：表示要创建的元素的数量。 val：表示要插入到链表中每个位置的默认值。

以下是该构造函数的示例用法：

#include <iostream>
#include <list>

int main() {
    // 创建一个包含5个元素的链表，每个元素的值都为100
    std::list<int> myList(5, 100);
    
    // 遍历链表并输出元素
    for (const auto& element : myList) {
        std::cout << element << " ";
    }
    std::cout << std::endl;
    
    return 0;
}

//100 100 100 100 100

2）list() 构造空的list

list类也提供了一个默认构造函数 list()，该构造函数创建一个空链表，不包含任何元素。

list的默认构造函数 list() 用于创建一个空链表。我们可以通过链表操作函数（如 push_back()、push_front() 等）向链表中添加元素，完成链表的构建。

#include <iostream>
#include <list>

int main() {
    // 创建一个空链表
    std::list<int> myList;
    
    // 在链表末尾添加元素
    myList.push_back(10);
    myList.push_back(20);
    myList.push_back(30);
    
    // 遍历链表并输出元素
    for (const auto& element : myList) {
        std::cout << element << " ";
    }
    std::cout << std::endl;
    
    return 0;
}

//10 20 30

3）list (const list& x) 拷贝构造函****数

list类还提供了一个拷贝构造函数 list(const list& x)，用于创建一个新的链表，其中包含与给定链表 x 中相同的元素。

list的拷贝构造函数 list(const list& x) 用于创建一个新的链表，其中包含与给定链表 x 中相同的元素。通过拷贝构造函数创建的链表与原始链表是独立的，对原始链表的修改不会反映在拷贝链表上。

以下是 list(const list& x) 拷贝构造函数的示例用法：

#include <iostream>
#include <list>

int main() {
    // 创建一个链表
    std::list<int> originalList{1, 2, 3, 4, 5};
    
    // 使用拷贝构造函数创建另一个链表
    std::list<int> copiedList(originalList);
    
    // 修改原始链表
    originalList.push_back(6);
    
    // 遍历拷贝链表并输出元素
    for (const auto& element : copiedList) {
        std::cout << element << " ";
    }
    std::cout << std::endl;
    
    return 0;
}

//1 2 3 4 5

4）list (InputIterator first, InputIterator last)

list(InputIterator first, InputIterator last) 是 std::list 的范围构造函数，用于创建一个新的链表，其中包含从指定范围 [first, last) 中复制的元素。

list的范围构造函数 list(InputIterator first, InputIterator last) 用于创建一个新的链表，其中的元素是从指定范围 [first, last) 中复制过来的。可以通过传递容器的迭代器范围、数组指针加上元素个数等来指定范围。这样创建的链表将会包含与源范围中相同的元素，并且这些元素会被复制到新链表中，在新链表中重新分配独立的节点和数据。

以下是 list(InputIterator first, InputIterator last) 范围构造函数的示例用法：

#include <iostream>
#include <list>
#include <vector>

int main() {
    // 创建一个 vector，并初始化其中的元素
    std::vector<int> vec{1, 2, 3, 4, 5};
    
    // 使用范围构造函数创建一个链表，从 vector 中复制元素
    std::list<int> myList(vec.begin(), vec.end());
    
    // 遍历链表并输出元素
    for (const auto& element : myList) {
        std::cout << element << " ";
    }
    std::cout << std::endl;
    
    return 0;
}

//1 2 3 4 5

1.2.2 list iterator的使用

此处，大家可暂时将迭代器理解成一个指针，该指针指向list中的某个节点。

我们先来看begin和end以及rbegin和rend：

|--------------------------------------------------------------------------------------------------------------------------------------------|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| 函数声明 | 接口说明 |
| begin+ end | 返回第一个元素的迭代器 +返回最后一个元素下一个 位置的迭代器 |
| rbegin+ rend | 返回第一个元素的 reverse _ iterator , 即 end 位置 ，返回最后一个元素下一个位置的 reverse _ iterator , 即 begin 位置 |

1）begin和end

list 是一个双向链表容器，它提供了 begin() 和 end() 函数，用于获取指向链表首元素和尾后元素的迭代器。

begin() 函数返回一个指向链表首元素的迭代器，而 end() 函数返回一个指向链表尾后元素的迭代器。通过使用这两个函数返回的迭代器，可以在循环中遍历链表中的元素。

【注意】

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

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

以下是相关代码演示：

#include <iostream>
#include <list>

int main() {
    std::list<int> myList = {1, 2, 3, 4, 5};

    // 使用 begin() 获取链表首元素的迭代器
    std::list<int>::iterator itBegin = myList.begin();

    // 使用 end() 获取链表尾后元素的迭代器
    std::list<int>::iterator itEnd = myList.end();

    // 输出链表中的元素
    for (std::list<int>::iterator it = itBegin; it != itEnd; ++it) {
        std::cout << *it << " ";
    }
    std::cout << std::endl;

    return 0;
}

//1 2 3 4 5

2）rbegin 和 rend

list 是一个双向链表容器，它还提供了 rbegin() 和 rend() 函数，用于获取指向链表逆序首元素和逆序尾后元素的反向迭代器。

rbegin() 函数返回一个指向链表逆序首元素的反向迭代器，而 rend() 函数返回一个指向链表逆序尾后元素的反向迭代器。通过使用这两个函数返回的反向迭代器，可以在循环中逆序遍历链表中的元素。

以下是相关代码演示：

#include <iostream>
#include <list>

int main() {
    std::list<int> myList = {1, 2, 3, 4, 5};

    // 使用 rbegin() 获取链表逆序首元素的反向迭代器
    std::list<int>::reverse_iterator itRbegin = myList.rbegin();

    // 使用 rend() 获取链表逆序尾后元素的反向迭代器
    std::list<int>::reverse_iterator itRend = myList.rend();

    // 输出链表中的元素（逆序）
    for (std::list<int>::reverse_iterator it = itRbegin; it != itRend; ++it) {
        std::cout << *it << " ";
    }
    std::cout << std::endl;

    return 0;
}

//5 4 3 2 1