C++的STL简介（四）

熬夜苦读学习2024-08-06 23:49

目录

1.List

[2.list 模拟实现](#2.list 模拟实现)

2.1基本框架

[2.2 list_node](#2.2 list_node)

[2.3 list](#2.3 list)

[2.3.1 默认构造](#2.3.1 默认构造)

[2.3.2 析构函数](#2.3.2 析构函数)

[2.3.3 begin（）](#2.3.3 begin（）)

[2.3.4 end（）](#2.3.4 end（）)

[2.3.5 size（）](#2.3.5 size（）)

[2.3.6 empty（）](#2.3.6 empty（）)

[2.3.7 insert（）](#2.3.7 insert（）)

[2.3.8 push_back()](#2.3.8 push_back())

[2.3.9 push_front（）](#2.3.9 push_front（）)

[2.3.10 erase （）](#2.3.10 erase （）)

[2.3.11 pop_back()](#2.3.11 pop_back())

[2.3.12 pop_front()](#2.3.12 pop_front())

[2.4 list_iterator](#2.4 list_iterator)

[2.4.1 - >](#2.4.1 - >)

[2.4.2 *](#2.4.2 *)

[2.4.3 前置++](#2.4.3 前置++)

[2.4.4 后置++](#2.4.4 后置++)

[2.4.5 前置--](#2.4.5 前置--)

[2.4.6 后置 --](#2.4.6 后置 --)

[2.4.7 ！=](#2.4.7 ！=)

[2.4.8 list_iterator完整代码](#2.4.8 list_iterator完整代码)

[2.5 list_const_iterator](#2.5 list_const_iterator)

3.整个实现完整代码

1.List

  • List是连续的容器，而vector是非连续的容器，即list将元素存储在连续的存储器中，而vector存储在不连续的存储器中。

  • 向量（vector）中间的插入和删除是非常昂贵的，因为它需要大量的时间来移动所有的元素。链表克服了这个问题，它是使用list容器实现的。

  • List支持双向，并为插入和删除操作提供了一种有效的方法。

  • 在列表中遍历速度很慢，因为列表元素是按顺序访问的，而vector支持随机访问。

2.list 模拟实现

2.1基本框架

list_node来实现每个节点，list_iterator和list_const_iterator是两个不同版本的迭代器一个是普通迭代器一个是const类型的迭代器，名字上也有所区分，list本身就有迭代器的效果，这个是为了模拟这个，重载了一些基本运算符，而list是统一管理节点，具有增删查改等效果

cpp 复制代码 
#define _CRT_SECURE_NO_WARNINGS 1
#include <iostream>
#include <cassert>
#include <algorithm> // For std::reverse

using namespace std;

namespace List
{
    // 节点类
    template<class T>
    class list_node
    {
    public:
        T _data;
        list_node<T>* _next;
        list_node<T>* _prev;

        list_node(const T& data = T())
            : _data(data)
            , _next(nullptr)
            , _prev(nullptr)
        {}
    };

//list迭代器
    template<class T>
    struct list_iterator
    {
        typedef list_node<T> Node;
        typedef list_iterator<T> Self;

        Node* _node;

        list_iterator(Node* node)
            : _node(node)
        { }

       
      
    };

//const版本迭代器
    template<class T>
    struct list_const_iterator
    {
        typedef list_node<T> Node;
        typedef list_const_iterator<T> Self;

        Node* _node;

        // 修正: list_const_iterator 的构造函数应该接受 Node* 类型
        list_const_iterator(Node* node)
            : _node(node)
        { }

    
    };
//实现list
    template<class T>
    class list
    {
        typedef list_node<T> Node;
    public:
        typedef list_iterator<T> iterator;
        typedef list_const_iterator<T> const_iterator;

        list()
        {
            _head = new Node(T());
            _head->_next = _head;
            _head->_prev = _head;
            _size = 0;
        }


        ~list()
        {
            while (!empty())
            {
                pop_front();
            }
            delete _head;
        }

    private:
        Node* _head;
        size_t _size;
    };

  
}
2.2 list_node

定义节点

cpp 复制代码 
  template<class T>
  class list_node
  {
  public:
      T _data;
      list_node<T>* _next;
      list_node<T>* _prev;

      list_node(const T& data = T())
          : _data(data)
          , _next(nullptr)
          , _prev(nullptr)
      {}
  };
2.3 list

维护节点

cpp 复制代码 
//实现list
    template<class T>
    class list
    {
        typedef list_node<T> Node;
    public:
        typedef list_iterator<T> iterator;
        typedef list_const_iterator<T> const_iterator;

        list()
        {
            _head = new Node(T());
            _head->_next = _head;
            _head->_prev = _head;
            _size = 0;
        }


        ~list()
        {
            while (!empty())
            {
                pop_front();
            }
            delete _head;
        }

    private:
        Node* _head;
        size_t _size;
    };
2.3.1 默认构造
cpp 复制代码 
//默认构造

 list()
 {
     _head = new Node(T());
     _head->_next = _head;
     _head->_prev = _head;
     _size = 0;
 }
2.3.2 析构函数
cpp 复制代码 
//析构函数

 ~list()
 {
     while (!empty())
     {
         pop_front();
     }
     delete _head;
 }
2.3.3 begin（）

开始位置的迭代器

cpp 复制代码 
//begin（）

 iterator begin()
 {
     return iterator(_head->_next);
 }

//const 
 const_iterator begin() const
 {
     return const_iterator(_head->_next);
 }
2.3.4 end（）

结尾位置的迭代器

cpp 复制代码 
//普通版

 iterator end()
 {
     return iterator(_head);
 }

 //const版

 const_iterator end() const
 {
     return const_iterator(_head);
 }
2.3.5 size（）

数据个数

cpp 复制代码 
size_t size() const
 {
     return _size;
 }
2.3.6 empty（）

判空

cpp 复制代码 
bool empty() const
 {
     return _size == 0;
 }
2.3.7 insert（）

指定位置插入

cpp 复制代码 
void insert(iterator pos, const T& x)
 {
     Node* cur = pos._node;
     Node* prev = cur->_prev;
     Node* newnode = new Node(x);

     //prev newnode cur
     newnode->_next = cur;
     cur->_prev = newnode;
     newnode->_prev = prev;
     prev->_next = newnode;

     ++_size;
 }
2.3.8 push_back()

尾插

cpp 复制代码 
 void push_back(const T& x)
 {
     insert(end(), x);
 }
2.3.9 push_front（）

头插

cpp 复制代码 
void push_front(const T& x)
 {
     insert(begin(), x);
 }
2.3.10 erase （）

指定位置删除

cpp 复制代码 
void erase(iterator pos)
 {
     assert(pos != end());
     Node* prev = pos._node->_prev;
     Node* next = pos._node->_next;

     prev->_next = next;
     next->_prev = prev;
     delete pos._node;
     --_size;
 }
2.3.11 pop_back()

尾删

cpp 复制代码 
 void pop_back()
 {
     erase(--end());
 }
2.3.12 pop_front()

头删

cpp 复制代码 
 void pop_front()
 {
     erase(begin());
 }

2.3.13 list完整代码

cpp 复制代码 
  template<class T>
  class list
  {
      typedef list_node<T> Node;
  public:
      typedef list_iterator<T> iterator;
      typedef list_const_iterator<T> const_iterator;

      list()
      {
          _head = new Node(T());
          _head->_next = _head;
          _head->_prev = _head;
          _size = 0;
      }

      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);
      }

      size_t size() const
      {
          return _size;
      }

      bool empty() const
      {
          return _size == 0;
      }

      void insert(iterator pos, const T& x)
      {
          Node* cur = pos._node;
          Node* prev = cur->_prev;
          Node* newnode = new Node(x);

          //prev newnode cur
          newnode->_next = cur;
          cur->_prev = newnode;
          newnode->_prev = prev;
          prev->_next = newnode;

          ++_size;
      }

      void push_back(const T& x)
      {
          insert(end(), x);
      }

      void push_front(const T& x)
      {
          insert(begin(), x);
      }

      void erase(iterator pos)
      {
          assert(pos != end());
          Node* prev = pos._node->_prev;
          Node* next = pos._node->_next;

          prev->_next = next;
          next->_prev = prev;
          delete pos._node;
          --_size;
      }

      void pop_back()
      {
          erase(--end());
      }

      void pop_front()
      {
          erase(begin());
      }

      ~list()
      {
          while (!empty())
          {
              pop_front();
          }
          delete _head;
      }

  private:
      Node* _head;
      size_t _size;
  };
2.4 list_iterator

为了支持list迭代器效果而模拟实现了一个迭代器

cpp 复制代码 
 template<class T>
 struct list_iterator
 {
     typedef list_node<T> Node;
     typedef list_iterator<T> Self;

     Node* _node;

     list_iterator(Node* node)
         : _node(node)
     { }

    
 };
2.4.1 - >
cpp 复制代码 
 // 修正: 返回指向 _data 的指针，而不是引用
     T* operator->()
     {
         return &_node->_data;
     }
2.4.2 *
cpp 复制代码 
     T& operator*()
     {
         return _node->_data;
     }
2.4.3 前置++
cpp 复制代码 
  Self& operator++()
     {
         _node = _node->_next;
         return *this;
     }
2.4.4 后置++
cpp 复制代码 
  Self operator++(int)
     {
         Self tmp(*this);
         _node = _node->_next;
         return tmp;
     }
2.4.5 前置--
cpp 复制代码 
 Self& operator--()
     {
         _node = _node->_prev;
         return *this;
     }
2.4.6 后置 --
cpp 复制代码 
     Self operator--(int)
     {
         Self tmp(*this);
         _node = _node->_prev;
         return tmp;
     }
2.4.7 ！=
cpp 复制代码 
bool operator!=(const Self& x) const
     {
         return _node != x._node;
     }
2.4.8 list_iterator完整代码
cpp 复制代码 
 template<class T>
 struct list_iterator
 {
     typedef list_node<T> Node;
     typedef list_iterator<T> Self;

     Node* _node;

     list_iterator(Node* node)
         : _node(node)
     { }

     // 修正: 返回指向 _data 的指针，而不是引用
     T* operator->()
     {
         return &_node->_data;
     }

     T& operator*()
     {
         return _node->_data;
     }

     Self& operator++()
     {
         _node = _node->_next;
         return *this;
     }

     Self operator++(int)
     {
         Self tmp(*this);
         _node = _node->_next;
         return tmp;
     }

     Self& operator--()
     {
         _node = _node->_prev;
         return *this;
     }

     Self operator--(int)
     {
         Self tmp(*this);
         _node = _node->_prev;
         return tmp;
     }

     bool operator!=(const Self& x) const
     {
         return _node != x._node;
     }
 };
2.5 list_const_iterator

list_const_iterator和list_iterator实现原理一致，只是有些成员函数被const修饰，typedef了const

cpp 复制代码 
 template<class T>
 struct list_const_iterator
 {
     typedef list_node<T> Node;
     typedef list_const_iterator<T> Self;

     Node* _node;

     // 修正: list_const_iterator 的构造函数应该接受 Node* 类型
     list_const_iterator(Node* node)
         : _node(node)
     { }

     // 修正: 返回指向 _data 的 const 指针，而不是引用
     const T* operator->() const
     {
         return &_node->_data;
     }

     const T& operator*() const
     {
         return _node->_data;
     }

     Self& operator++()
     {
         _node = _node->_next;
         return *this;
     }

     Self operator++(int)
     {
         Self tmp(*this);
         _node = _node->_next;
         return tmp;
     }

     Self& operator--()
     {
         _node = _node->_prev;
         return *this;
     }

     Self operator--(int)
     {
         Self tmp(*this);
         _node = _node->_prev;
         return tmp;
     }

     bool operator!=(const Self& x) const
     {
         return _node != x._node;
     }
 };

3.整个实现完整代码

cpp 复制代码 
#define _CRT_SECURE_NO_WARNINGS 1
#include <iostream>
#include <cassert>
#include <algorithm> // For std::reverse

using namespace std;

namespace List
{
    // 节点类
    template<class T>
    class list_node
    {
    public:
        T _data;
        list_node<T>* _next;
        list_node<T>* _prev;

        list_node(const T& data = T())
            : _data(data)
            , _next(nullptr)
            , _prev(nullptr)
        {}
    };

    template<class T>
    struct list_iterator
    {
        typedef list_node<T> Node;
        typedef list_iterator<T> Self;

        Node* _node;

        list_iterator(Node* node)
            : _node(node)
        { }

        // 修正: 返回指向 _data 的指针，而不是引用
        T* operator->()
        {
            return &_node->_data;
        }

        T& operator*()
        {
            return _node->_data;
        }

        Self& operator++()
        {
            _node = _node->_next;
            return *this;
        }

        Self operator++(int)
        {
            Self tmp(*this);
            _node = _node->_next;
            return tmp;
        }

        Self& operator--()
        {
            _node = _node->_prev;
            return *this;
        }

        Self operator--(int)
        {
            Self tmp(*this);
            _node = _node->_prev;
            return tmp;
        }

        bool operator!=(const Self& x) const
        {
            return _node != x._node;
        }
    };

    template<class T>
    struct list_const_iterator
    {
        typedef list_node<T> Node;
        typedef list_const_iterator<T> Self;

        Node* _node;

        // 修正: list_const_iterator 的构造函数应该接受 Node* 类型
        list_const_iterator(Node* node)
            : _node(node)
        { }

        // 修正: 返回指向 _data 的 const 指针，而不是引用
        const T* operator->() const
        {
            return &_node->_data;
        }

        const T& operator*() const
        {
            return _node->_data;
        }

        Self& operator++()
        {
            _node = _node->_next;
            return *this;
        }

        Self operator++(int)
        {
            Self tmp(*this);
            _node = _node->_next;
            return tmp;
        }

        Self& operator--()
        {
            _node = _node->_prev;
            return *this;
        }

        Self operator--(int)
        {
            Self tmp(*this);
            _node = _node->_prev;
            return tmp;
        }

        bool operator!=(const Self& x) const
        {
            return _node != x._node;
        }
    };

    template<class T>
    class list
    {
        typedef list_node<T> Node;
    public:
        typedef list_iterator<T> iterator;
        typedef list_const_iterator<T> const_iterator;

        list()
        {
            _head = new Node(T());
            _head->_next = _head;
            _head->_prev = _head;
            _size = 0;
        }

        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);
        }

        size_t size() const
        {
            return _size;
        }

        bool empty() const
        {
            return _size == 0;
        }

        void insert(iterator pos, const T& x)
        {
            Node* cur = pos._node;
            Node* prev = cur->_prev;
            Node* newnode = new Node(x);

            //prev newnode cur
            newnode->_next = cur;
            cur->_prev = newnode;
            newnode->_prev = prev;
            prev->_next = newnode;

            ++_size;
        }

        void push_back(const T& x)
        {
            insert(end(), x);
        }

        void push_front(const T& x)
        {
            insert(begin(), x);
        }

        void erase(iterator pos)
        {
            assert(pos != end());
            Node* prev = pos._node->_prev;
            Node* next = pos._node->_next;

            prev->_next = next;
            next->_prev = prev;
            delete pos._node;
            --_size;
        }

        void pop_back()
        {
            erase(--end());
        }

        void pop_front()
        {
            erase(begin());
        }

        ~list()
        {
            while (!empty())
            {
                pop_front();
            }
            delete _head;
        }

    private:
        Node* _head;
        size_t _size;
    };

    void test1()
    {
        list<int> lt;
        lt.push_back(1);
        lt.push_back(2);

        list<int>::iterator it = lt.begin();
        while (it != lt.end())
        {
            cout << *it << " ";
            ++it;
        }
        cout << endl;
    }
}
相关推荐
爱吃桃子的ICer39 分钟前
[UVM]3.核心基类 uvm_object 域的自动化 copy() compare() print() pack unpack
开发语言·前端·ic设计
ever_up9732 小时前
EasyExcel的导入与导出及在实际项目生产场景的一下应用例子
java·开发语言·数据库
吴天德少侠2 小时前
c++返回一个pair类型
开发语言·c++
小小小小关同学3 小时前
Spring Cloud LoadBalancer
后端·spring·spring cloud
ok!ko3 小时前
设计模式之工厂模式(通俗易懂--代码辅助理解【Java版】）
java·开发语言·设计模式
学地理的小胖砸3 小时前
【GEE的Python API】
大数据·开发语言·前端·python·遥感·地图学·地理信息科学
八月的雨季 最後的冰吻4 小时前
C--字符串函数处理总结
c语言·前端·算法
qq_317060954 小时前
java之http client工具类
java·开发语言·http
robot_大菜鸟4 小时前
python_openCV_计算图片中的区域的黑色比例
开发语言·python·opencv
Pandaconda5 小时前
【C++ 面试 - 新特性】每日 3 题（六）
开发语言·c++·经验分享·笔记·后端·面试·职场和发展
热门推荐
0151-2 万字长文，深度解读端到端自动驾驶的挑战和前沿022024年高教社杯数学建模国赛C题超详细解题思路分析03【2024数模国赛赛题思路公开】国赛B题思路丨附可运行代码丨无偿自提04RAG 实践- Ollama+RagFlow 部署本地知识库05【2024高教社杯全国大学生数学建模竞赛】B题 生产过程中的决策问题——解题思路 代码 论文062024 高教社杯 数学建模国赛 （A题）深度剖析|“板凳龙” 闹元宵|数学建模完整代码+建模过程全解全析07Coze扣子平台完整体验和实践（附国内和国际版对比）082024年高教杯国赛（C题）数学建模竞赛解题思路|完整代码论文集合092024 年高教社杯全国大学生数学建模竞赛题目-A 题 “板凳龙” 闹元宵10【SCS-CN】SCS-CN模型中CN值的确定