【C++】STL——list（万字详解）

ゞ浴缸里的玫瑰 2024-04-20 06:14 77阅读 0赞

> **?C++学习历程：STL**
> 
> --------------------
> 
>  *  **博客主页：**[一起去看日落吗][Link 1]
>  *  **持续分享博主的C++学习历程**
>  *  **`博主的能力有限，出现错误希望大家不吝赐教`**
>  *  **分享给大家一句我很喜欢的话：** 也许你现在做的事情，暂时看不到成果，但不要忘记，树?成长之前也要扎根，也要在漫长的时光?中沉淀养分。静下来想一想，哪有这么多的天赋异禀，那些让你羡慕的优秀的人也都曾默默地翻山越岭?。
> 
> --------------------
> 
> ![在这里插入图片描述][eabca17da9704379a5f15832a495b4cc.jpeg_pic_center]

✨ ⭐️ ? ?

--------------------

#### 目录 ####

*  ✨ 1. list的介绍及使用
 *   *  ? 1.1 list的介绍
     *  ? 1.2 list的使用
     *   *  ⭐️ 1.2.1 list的构造
         *  ⭐️ 1.2.2 list iterator的使用
         *  ⭐️ 1.2.3 list capacity
         *  ⭐️ 1.2.4 list element access
         *  ⭐️ 1.2.5 list modifiers
         *  ⭐️ 1.2.6 list的使用演示
         *  ⭐️ 1.2.7 list的迭代器失效
 *  ✨ 2. list的模拟实现
 *   *  ? 2.1 模拟实现list
 *  ✨ 3. list与vector的对比

## ✨ 1. list的介绍及使用 ##

### ? 1.1 list的介绍 ###

[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来说这可能是一个重要的因素)

![在这里插入图片描述][586b07b19aac4956a5990ed05b55281a.png]

--------------------

### ? 1.2 list的使用 ###

![在这里插入图片描述][be45c9bef1ab46dd8b67b7af1b748740.png_pic_center]

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

#### ⭐️ 1.2.1 list的构造 ####

<table> 
 <thead> 
  <tr> 
   <th>构造函数（ (constructor)）</th> 
   <th>接口说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>list (size_type n, const value_type&amp; val = value_type())</td> 
   <td>构造的list中包含n个值为val的元素</td> 
  </tr> 
  <tr> 
   <td>list()</td> 
   <td>构造空的list</td> 
  </tr> 
  <tr> 
   <td>list (const list&amp; x)</td> 
   <td>拷贝构造函数</td> 
  </tr> 
  <tr> 
   <td>list (InputIterator first, InputIterator last)</td> 
   <td>用[first, last)区间中的元素构造list</td> 
  </tr> 
 </tbody> 
</table>

![请添加图片描述][ed959146bc374001a2ae6396bcbc9da4.png]

--------------------

#### ⭐️ 1.2.2 list iterator的使用 ####

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

<table> 
 <thead> 
  <tr> 
   <th>iterator</th> 
   <th>接口说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>begin + end</td> 
   <td>返回第一个元素的迭代器 + 返回最后一个元素下一个位置的迭代器</td> 
  </tr> 
  <tr> 
   <td>rbegin + rend</td> 
   <td>返回第一个元素的 reserve_iterator，即 end 位置，返回最后一个元素下一个位置的 reverse_iterator，即 begin 位置</td> 
  </tr> 
 </tbody> 
</table>

![请添加图片描述][5c7ef5dbd4494ab18619e06908e01a76.png]

![请添加图片描述][a5f31283b2d74ab4bf91ee7d87f175af.png]

![请添加图片描述][d1fe9f4a7eb644e4843cc1f1b975f200.png]

![请添加图片描述][34b728c99ad14ad385d57eb9d9017ffa.png]

![在这里插入图片描述][de4cc8ab9a9e4b15bedd4f2358d68724.png]

**【注意】**

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

--------------------

#### ⭐️ 1.2.3 list capacity ####

<table> 
 <thead> 
  <tr> 
   <th>函数声明</th> 
   <th>接口说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>empty</td> 
   <td>检测list是否为空，是返回true，否则返回false</td> 
  </tr> 
  <tr> 
   <td>size</td> 
   <td>返回list中有效节点的个数</td> 
  </tr> 
 </tbody> 
</table>

![请添加图片描述][76aa7c13ca2643208d270f3a6338afc4.png]

![请添加图片描述][d8d4e5c31ebf44a88b23261482947832.png]

--------------------

#### ⭐️ 1.2.4 list element access ####

<table> 
 <thead> 
  <tr> 
   <th>函数声明</th> 
   <th>接口说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>front</td> 
   <td>返回list的第一个节点中值的引用</td> 
  </tr> 
  <tr> 
   <td>back</td> 
   <td>返回list的最后一个节点中值的引用</td> 
  </tr> 
 </tbody> 
</table>

![请添加图片描述][86fe20e82fe248b9aa673a41fb51f4f9.png]

![请添加图片描述][8cab28a0d65144ff82e7faffc94f3945.png]

--------------------

#### ⭐️ 1.2.5 list modifiers ####

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

![请添加图片描述][4f597e6e88b646fc814cbff3d6597ac1.png]

![请添加图片描述][2588989080164560aa8d74a1e33f3f20.png]

![请添加图片描述][8f853d9a0285438181117d7fbcd99523.png]

--------------------

![请添加图片描述][3e3d8092fd1b499b82e36894ab4b239a.png]

![请添加图片描述][da70aa39a87c4fe6a05432ff72140a19.png]

![请添加图片描述][d7014792aece46da9d6127de45cc54a4.png]

![请添加图片描述][65336cf3496c49b2b649b47c587308df.png]

![请添加图片描述][a305e696ac3c4bc38ebd1ee669005d42.png]

--------------------

#### ⭐️ 1.2.6 list的使用演示 ####

`main.cpp`

#define _CRT_SECURE_NO_WARNINGS
    
    #include <iostream>
    using namespace std;
    #include <list>
    #include <vector>
    
    
    
    // list的构造
    void TestList1()
    {
        
        list<int> l1;                         // 构造空的l1
        list<int> l2(4, 100);                 // l2中放4个值为100的元素
        list<int> l3(l2.begin(), l2.end());  // 用l2的[begin(), end()）左闭右开的区间构造l3
        list<int> l4(l3);                    // 用l3拷贝构造l4
    
        // 以数组为迭代器区间构造l5
        int array[] = {
         16,2,77,29 };
        list<int> l5(array, array + sizeof(array) / sizeof(int));
    
        // 列表格式初始化C++11
        list<int> l6{
         1,2,3,4,5 };
    
        // 用迭代器方式打印l5中的元素
        list<int>::iterator it = l5.begin();
        while (it != l5.end())
        {
        
            cout << *it << " ";
            ++it;
        }       
        cout << endl;
    
        // C++11范围for的方式遍历
        for (auto& e : l5)
            cout << e << " ";
    
        cout << endl;
    }
    
    
    // list迭代器的使用
    // 注意：遍历链表只能用迭代器和范围for
    void PrintList(const list<int>& l)
    {
        
        // 注意这里调用的是list的 begin() const，返回list的const_iterator对象
        for (list<int>::const_iterator it = l.begin(); it != l.end(); ++it)
        {
        
            cout << *it << " ";
            // *it = 10; 编译不通过
        }
    
        cout << endl;
    }
    
    void TestList2()
    {
        
        int array[] = {
         1, 2, 3, 4, 5, 6, 7, 8, 9, 0 };
        list<int> l(array, array + sizeof(array) / sizeof(array[0]));
        // 使用正向迭代器正向list中的元素
        // list<int>::iterator it = l.begin();   // C++98中语法
        auto it = l.begin();                     // C++11之后推荐写法
        while (it != l.end())
        {
        
            cout << *it << " ";
            ++it;
        }
        cout << endl;
    
        // 使用反向迭代器逆向打印list中的元素
        // list<int>::reverse_iterator rit = l.rbegin();
        auto rit = l.rbegin();
        while (rit != l.rend())
        {
        
            cout << *rit << " ";
            ++rit;
        }
        cout << endl;
    }
    
    
    // list插入和删除
    // push_back/pop_back/push_front/pop_front
    void TestList3()
    {
        
        int array[] = {
         1, 2, 3 };
        list<int> L(array, array + sizeof(array) / sizeof(array[0]));
    
        // 在list的尾部插入4，头部插入0
        L.push_back(4);
        L.push_front(0);
        PrintList(L);
    
        // 删除list尾部节点和头部节点
        L.pop_back();
        L.pop_front();
        PrintList(L);
    }
    
    // insert /erase 
    void TestList4()
    {
        
        int array1[] = {
         1, 2, 3 };
        list<int> L(array1, array1 + sizeof(array1) / sizeof(array1[0]));
    
        // 获取链表中第二个节点
        auto pos = ++L.begin();
        cout << *pos << endl;
    
        // 在pos前插入值为4的元素
        L.insert(pos, 4);
        PrintList(L);
    
        // 在pos前插入5个值为5的元素
        L.insert(pos, 5, 5);
        PrintList(L);
    
        // 在pos前插入[v.begin(), v.end)区间中的元素
        vector<int> v{
         7, 8, 9 };
        L.insert(pos, v.begin(), v.end());
        PrintList(L);
    
        // 删除pos位置上的元素
        L.erase(pos);
        PrintList(L);
    
        // 删除list中[begin, end)区间中的元素，即删除list中的所有元素
        L.erase(L.begin(), L.end());
        PrintList(L);
    }
    
    // resize/swap/clear
    void TestList5()
    {
        
        // 用数组来构造list
        int array1[] = {
         1, 2, 3 };
        list<int> l1(array1, array1 + sizeof(array1) / sizeof(array1[0]));
        PrintList(l1);
    
        // 交换l1和l2中的元素
        list<int> l2;
        l1.swap(l2);
        PrintList(l1);
        PrintList(l2);
    
        // 将l2中的元素清空
        l2.clear();
        cout << l2.size() << endl;
    }

--------------------

#### ⭐️ 1.2.7 list的迭代器失效 ####

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

#include<iostream>
    #include<algorithm>
    #include<list>
    using namespace std;
    
    namespace byh
    {
        
    	void test_list1()
    	{
        
    		int array[] = {
         1, 2, 3, 4, 5, 6, 7, 8, 9, 0 };
    		list<int> lt(array, array + sizeof(array) / sizeof(array[0]));
    		list<int>::iterator pos = find(lt.begin(), lt.end(), 5);
    		if(pos != lt.end())
    		{
        
    			//不会失效
    			lt.insert(pos, 45);
    		}
    		for(auto e : lt)
    		{
        
    			cout << e << " ";	
    		}
    		cout << endl;
    	}
    	void test_list2()
    	{
        
    		int array[] = {
         1, 2, 3, 4, 5, 6, 7, 8, 9, 0 };
    		list<int> lt(array, array + sizeof(array) / sizeof(array[0]));
    		list<int>::iterator pos = find(lt.begin(), lt.end(), 5);
    		if(pos != lt.end())
    		{
        
    			//会失效,可以重新指定迭代器pos
    			lt.erase(pos);
    			//pos = lt.erase(pos);//ok
    		}
    		cout << *pos << endl;
    		cout << endl;
    	}
    }
    int main()
    {
        
    	byh::test_list1();
    	byh::test_list2();
    	return 0;	
    }

--------------------

## ✨ 2. list的模拟实现 ##

### ? 2.1 模拟实现list ###

//
    //  main.cpp
    //  模拟实现list
    //
    //  Created by 卜绎皓 on 2022/10/22.
    //
    
    #include<iostream>
    #include<stdbool.h>
    #include<assert.h>
    using namespace std;
    
    
    #pragma once
    
    namespace byh
    {
        
        template<class T>
        struct __list_node//一般前面使用__,表示给内部使用,为什么不使用内部类,因为不仅仅list要用它,迭代器也要用它(C++里还是比较少用内部类的)
        {
        
            __list_node<T>* _next;
            __list_node<T>* _prev;
            T _data;
    
            //这里支持无参的new Node,或者有参的new Node(x)
            __list_node(const T& x = T())
                : _next(nullptr)
                , _prev(nullptr)
                , _data(x)
            {
        }
        };
    
        //迭代器,用一个类去封装节点的指针,所以目前为止我们已知的迭代器的实现方式有两种:
        //a)原生指针(天然迭代器),它所指向的空间物理结构是连续的,也就是说只有string、vector才可以做天然迭代器(*就是当前位置的数据/++就是下一个位置/--就是下一个位置)
        //b)类(用一个类去封装原生指针,重载相关运算符,让这个类对象用起来像指针),它所指向的空间物理结构是不连续的(没有封装指针之前,*是结构体/++--的位置不明确)
        //iterator:<T, T&, T*>
        //const_iterator<T, const T&, const T*>
        template<class T, class Ref, class Ptr>
        struct __list_iterator
        {
        
            typedef __list_iterator<T, Ref, Ptr> self;
            typedef __list_node<T> Node;
            Node* _node;
    
            __list_iterator(Node* node)
                : _node(node)
            {
        }
    
            //*it
            Ref operator*()
            {
        
                return _node->_data;
            }
    
            //
            Ptr operator->()
            {
        
                return     &_node->_data;
            }
    
            //++it
            self& operator++()
            {
        
                _node = _node->_next;
                return *this;
            }
    
            //it++,tmp出了作用域销毁,传值返回,不能用引用
            self operator++(int)
            {
        
                //备份
                self tmp(*this);
                _node = _node->_next;
                return tmp;
            }
    
            //--it
            self& operator--()
            {
        
                _node = _node->_prev;
                return *this;
            }
    
            //it--
            self operator--(int)
            {
        
                self tmp(*this);
                _node = _node->_prev;
                return tmp;
            }
    
            //it+,它可以operator+(),但是效率很低,所以也就没有支持
    
            //lt.begin() != lt.end()
            bool operator!=(const self& it) const
            {
        
                return _node != it._node;
            }
    
            //lt.begin() == lt.end()
            bool operator==(const self& it) const
            {
        
                return _node == it._node;
            }
        };
    
        template<class T>
        class list
        {
        
            //这个不想让外面的人用,所以默认是私有的
            typedef __list_node<T> Node;
        public:
            //__list_iterator是什么名字并不重要,最终都会typedef为iterator,因为我们要用统一的方式去访问容器。比如vector<int>::iterator;你那个真正的迭代器是什么名称不重要
            //typedef __list_iterator<T> iterator;
            //typedef __list_const_iterator<T> const_iterator;
            typedef __list_iterator<T, T&, T*> iterator;
            typedef __list_iterator<T, const T&, const T*> const_iterator;
    
            iterator begin()
            {
        
                return iterator(_head->_next);
            }
            iterator end()
            {
        
                return iterator(_head);//最后一个节点的下一个位置,哨兵位
            }
    
            const_iterator begin() const
            {
        
                return const_iterator(_head->_next);
            }
            const_iterator end() const
            {
        
                return const_iterator(_head);
            }
    
            list()
            {
        
                //带头双向循环链表
                _head = new Node;
                _head->_next = _head;
                _head->_prev = _head;
            }
        
            //lt2(lt1)
            //传统写法
            /*list(const list<T>& lt)
            {
                _head = new Node;
                _head->_next = _head;
                _head->_prev = _head;
                
                for(const auto& e : lt)
                {
                    push_back(e);
                }
            }*/
            //现代写法,可以看到这里现代写法相比传统写法并没有讲到便宜,所以说现代写法也不一定是最优,需要灵活运用
            //它要先支持一个迭代器区间的才能写现代写法,同时这里支持其它容器的拷贝构造
            template<class InputIterator>
            list(InputIterator first, InputIterator last)
            {
        
                _head = new Node;
                _head->_next = _head;
                _head->_prev = _head;
    
                while (first != last)
                {
        
                    push_back(*first);
                    ++first;
                }
            }
            list(const list<T>& lt)
            {
        
                _head = new Node;
                _head->_next = _head;
                _head->_prev = _head;
    
                list<T> tmp(lt.begin(), lt.end());
                std::swap(_head, tmp._head);
            }
            
            //lt1 = lt2
            //传统写法
            /*list<T>& operator=(const list<T>& lt)
            {
                if(this != &lt)
                {
                    clear();
                    for(const auto& e : lt)
                    {
                        push_back(e);
                    }
                }
                return *this;
            }*/
            //现代写法,对于赋值有一个原则,深拷贝现代写法一定非常简单(只要写了拷贝构造,赋值就一定能用现代写法,并且很简洁)
            list<T>& operator=(list<T> lt)
            {
        
                swap(_head, lt._head);
                return *this;
            }
            
            //对于~list,先实现clear
            ~list()
            {
        
                clear();
                //清除头节点
                delete _head;
                _head = nullptr;
            }
    
            void clear()
            {
        
                iterator it = begin();
                while(it != end())
                {
        
                    //不清除头节点,直接复用
                    it = erase(it);
                }
            }
    
            void push_back(const T& x)
            {
        
                //同insert(_head, x);,end()是最后节点的下一个位置_head
                insert(end(), x);
            }
    
            void push_front(const T& x)
            {
        
                //insert(_head->_next, x);,begin()是头节点的下一个位置
                insert(begin(), x);
            }
    
            void pop_back()
            {
        
                //同erase(_head->_prev);
                erase(--end());
            }
    
            void pop_front()
            {
        
                //同erase(_head->_next);
                erase(begin());
            }
    
            iterator insert(iterator pos, const T& x)
            {
        
                //备份;这里就体现了为啥我们在设计__list_node和__list_iterator时为什么是struct,如果用class,这里就得用友源,但没必要
                Node* cur = pos._node;
                Node* prev = cur->_prev;
                Node* newnode = new Node(x);
    
                //关联
                prev->_next = newnode;
                newnode->_prev = prev;
                newnode->_next = cur;
                cur->_prev = newnode;
    
                //双向链表的insert是不会失效的,返回新插入的节点,这里同 __list_iterator<T> (newnode),且这里是一个匿名对象。
                return iterator(newnode);
                //同上,newnode是Node*(__list_node<T>)类型,而insert的返回类型是iterator(__list_iterator<T>)也可以,这是因为单参数的构造函数支持隐式类型转换,如 A aa = 1; 或 string s = "hello";。但因为不太明确,所以不太推荐
                //return newnode;
            }
            
            //虽然在外面调用list实例化了lt,但是list里面的函数编译器会按需实例化(外面调用了哪个成员函数,就实例化哪个)
            //erase不是模板?这里要注意类模板里的成员函数都是函数模板,erase的参数iterator就是typedef出来的模板
            iterator erase(iterator pos)
            {
        
                //空链表(只剩头节点)不能erase
                assert(pos != end());
    
                //备份
                Node* cur = pos._node;
                Node* prev = cur->_prev;
                Node* next = cur->_next;
    
                //释放
                delete cur;
    
                //关联
                prev->_next = next;
                next->_prev = prev;
    
                //返回删除元素之后的位置,注意这里的pos已经是野指针了
                return iterator(next);
            }
    
            size_t size()
            {
        
                size_t n = 0;
                iterator it = begin();
                while (it != end())
                {
        
                    ++it;
                    ++n;
                }
                return n;
            }
    
            bool empty()
            {
        
                return begin() == end();
            }
        private:
            Node* _head;
        };
    
        //const迭代器一般出现的场景是在传参的时候
        void print_list(const list<int>& l)
        {
        
            list<int>::const_iterator it = l.begin();
            while (it != l.end())
            {
        
                //*it += 2;//err,表达式必须是可修改的左值
                cout << *it << " ";
                ++it;
            }
            cout << endl;
        }
    
        void test_list1()
        {
        
            list<int> lt;
            lt.push_back(1);
            lt.push_back(2);
            lt.push_back(3);
            lt.push_back(4);
    
            print_list(lt);
    
            list<int>::iterator it = lt.begin();
            while (it != lt.end())
            {
        
                *it *= 2;
                cout << *it << " ";
                ++it;
            }
            cout << endl;
    
            for (auto e : lt)
            {
        
                cout << e << " ";
            }
            cout << endl;
        }
        
        struct TreeNode
        {
        
            struct TreeNode* _left;
            struct TreeNode* _right;
            int _val;
    
            TreeNode(int val = -1)
                : _left(nullptr)
                , _right(nullptr)
                , _val(val)
            {
        }
        };
        //ostream operator<<(ostream& TreeNode, TreeNode n){}
        
        void test_list2()
        {
        
            list<TreeNode> lt;
            lt.push_back(TreeNode(1));
            lt.push_back(TreeNode(2));
            lt.push_back(TreeNode(3));
            lt.push_back(TreeNode(4));
    
            list<TreeNode>::iterator it = lt.begin();
            while (it != lt.end())
            {
        
                //*it调operator*,返回_node->_data;,_data是T类型,而这的T是TreeNode,是一个结构体类型的树节点,而*it后是TreeNode,我们说了内置类型可以直接cout输出,但是自定义类型不行,所以我们可以operator<<,或者不用重载(使用结构体的特性)
                //cout << *it << " ";
                //有些场景不适合用cout
                //cout << (*it)._val << " ";
                //这是结构体的访问方式(结构体和指针的访问方式,细节如下说明 3. List item)
                printf("val:%d,left:%p,right:%p\n", (*it)._val, (*it)._left, (*it)._right);
                //像指针一样就要去重载->,[int* p   *p] [TreeNode* p     p->_val]
                printf("val:%d,left:%p,right:%p\n", it->_val, it->_left, it->_right);
                ++it;
            }
            cout << endl;
        }
        
        void test_list3()
        {
        
            list<int> lt;
            lt.push_back(1);
            lt.push_back(2);
            lt.push_back(3);
            lt.push_back(4);
            print_list(lt);
            
            lt.clear();
            
            lt.push_back(10);
            lt.push_back(20);
            lt.push_back(30);
            lt.push_back(40);
            print_list(lt);
        }
        
        void test_list4()
        {
        
            list<int> lt1;
            lt1.push_back(1);
            lt1.push_back(2);
            lt1.push_back(3);
            lt1.push_back(4);
            
            list<int> lt2(lt1);
            print_list(lt2);
    
            list<int> lt3(lt1.begin(), lt1.end());
    
            string s("hello");
            list<int> lt4(s.begin(), s.end());
        
            for (auto e : lt3)
            {
        
                cout << e << " ";
            }
            cout << endl;
            for (auto e : lt4)
            {
        
                cout << e << " ";
            }
            cout << endl;
    
            lt1 = lt4;
            for (auto e : lt1)
            {
        
                cout << e << " ";
            }
            cout << endl;
                                                                                                                                    
        }
    }
    
    
    
    
    
    int main()
    {
        
        byh::test_list1();
        byh::test_list2();
        byh::test_list3();
        byh::test_list4();
        return 0;
    }

--------------------

## ✨ 3. list与vector的对比 ##

**在 32 位的机器下 vector 和 list 的迭代器所占多少字节呢?**

相比 vector 的迭代器，就逻辑上来说 list 的迭代器就要复杂一点，**因为 vector 的迭代器是一个天然的迭代器，它是原生指针**，但要注意原生指针要做天然迭代器的要求是指针指向的物理空间是连续的。**而 list 不能做天然的迭代器，所以我们要将指针封装成一个类，让它完成指针的操作**。而就物理层面上来说 vector 和 list 的迭代器没有更复杂，也就是它们所占用的空间是一样的。至此，我们就可以看到 C++ 运算符重载的能力。

所以在 32 位的机器下 vector 的迭代器占 4 个字节；list 的迭代器也占 4 个字节。

vector与list都是STL中非常重要的序列式容器，由于两个容器的底层结构不同，导致其特性以及应用场景不同，其主要不同如下：

![请添加图片描述][8b2fa9e86a4245428ec099ebdc44bf88.png]

--------------------

[Link 1]: https://blog.csdn.net/m0_60338933?type=blog
[eabca17da9704379a5f15832a495b4cc.jpeg_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/20/6aeedd70d7304f6b97ca20af1b6b850c.jpeg
[list]: https://cplusplus.com/reference/list/list/?kw=list
[586b07b19aac4956a5990ed05b55281a.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/20/e93b99d4bc8a410ab82000193518f9af.png
[be45c9bef1ab46dd8b67b7af1b748740.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/20/9dcf85f0b8034ac3b8eaeb126d161f04.png
[ed959146bc374001a2ae6396bcbc9da4.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/20/8342968a12864f6fb0d35f845fb851e9.png
[5c7ef5dbd4494ab18619e06908e01a76.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/20/bec9798dd9a14f868492163c871e67fc.png
[a5f31283b2d74ab4bf91ee7d87f175af.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/20/083c7f9649ca417a853d325632d2b234.png
[d1fe9f4a7eb644e4843cc1f1b975f200.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/20/26634f0b5e264d5791af682f285c26b8.png
[34b728c99ad14ad385d57eb9d9017ffa.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/20/b5bff0584b6549d892f45fa8f2c9dda5.png
[de4cc8ab9a9e4b15bedd4f2358d68724.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/20/b3f0010e19f3411ab1e45bd29f6b6427.png
[76aa7c13ca2643208d270f3a6338afc4.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/20/68d31fa9801c461d81b4401cbe9b7dc0.png
[d8d4e5c31ebf44a88b23261482947832.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/20/a6ad539356b5484fa1d6b67c4b5a4056.png
[86fe20e82fe248b9aa673a41fb51f4f9.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/20/21c355804ec2429ea4109f131fe03fb2.png
[8cab28a0d65144ff82e7faffc94f3945.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/20/5f395c68a1e04540985924fb350bba26.png
[4f597e6e88b646fc814cbff3d6597ac1.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/20/8305297ab9e14de4afab8568b336afc1.png
[2588989080164560aa8d74a1e33f3f20.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/20/0087f30bd07e4108b8e2f460b56747ad.png
[8f853d9a0285438181117d7fbcd99523.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/20/4803843eca04433186782e3b4bd22666.png
[3e3d8092fd1b499b82e36894ab4b239a.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/20/689a2bb0f48446f7bab06d514e44a293.png
[da70aa39a87c4fe6a05432ff72140a19.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/20/c1c9b36de0e2429cbf7a795b54e7a7cd.png
[d7014792aece46da9d6127de45cc54a4.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/20/637db64bd8a74f6aacb1ad72be6077fc.png
[65336cf3496c49b2b649b47c587308df.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/20/35c7afe9439145cba40ec9f1d6ec5832.png
[a305e696ac3c4bc38ebd1ee669005d42.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/20/44047f04149d47cc8c2164549e362a5e.png
[8b2fa9e86a4245428ec099ebdc44bf88.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/20/2560d28ced7a4c56b9308770f86e805f.png