C++的STL简介（四）

已于 2024-08-02 18:35:32 修改
阅读量244 收藏 3
点赞数 7
分类专栏： C++ 文章标签： c++ 开发语言 c语言 后端
于 2024-08-02 18:32:50 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2302_81171591/article/details/140877205
版权

目录

1.List

2.list 模拟实现

2.1基本框架

2.2 list_node

2.3 list

2.3.1 默认构造

2.3.2 析构函数

2.3.3 begin（）

2.3.4 end（）

2.3.5 size（）

2.3.6 empty（）

2.3.7 insert（）

2.3.8 push_back()

2.3.9 push_front（）

2.3.10 erase （）

2.3.11 pop_back()

2.3.12 pop_front()

2.4 list_iterator

2.4.1 - >

2.4.2 *

2.4.3 前置++

2.4.4 后置++

2.4.5 前置--

2.4.6 后置 --

2.4.7 ！=

2.4.8 list_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是统一管理节点，具有增删查改等效果

#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

定义节点

  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

维护节点

//实现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 默认构造
//默认构造

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

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

开始位置的迭代器

//begin（）

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

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

结尾位置的迭代器

//普通版

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

 //const版

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

数据个数

size_t size() const
 {
     return _size;
 }
2.3.6 empty（）

判空

bool empty() const
 {
     return _size == 0;
 }
2.3.7 insert（）

指定位置插入

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()

尾插

 void push_back(const T& x)
 {
     insert(end(), x);
 }
2.3.9 push_front（）

头插

void push_front(const T& x)
 {
     insert(begin(), x);
 }
2.3.10 erase （）

指定位置删除

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()

尾删

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

头删



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

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

      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迭代器效果而模拟实现了一个迭代器

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


     T& operator*()
     {
         return _node->_data;
     }
2.4.3 前置++
  Self& operator++()
     {
         _node = _node->_next;
         return *this;
     }
2.4.4 后置++
  Self operator++(int)
     {
         Self tmp(*this);
         _node = _node->_next;
         return tmp;
     }
2.4.5 前置--
 Self& operator--()
     {
         _node = _node->_prev;
         return *this;
     }
2.4.6 后置 --

     Self operator--(int)
     {
         Self tmp(*this);
         _node = _node->_prev;
         return tmp;
     }
2.4.7 ！=
bool operator!=(const Self& x) const
     {
         return _node != x._node;
     }
2.4.8 list_iterator完整代码
 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 

 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.整个实现完整代码

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

熬夜苦读学习
关注
  • 7
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
C++ STL教程pdf
05-10
C++ STL，全称为Standard Template Library（标准模板库），是C++编程语言中不可或缺的一部分，它为程序员提供了高效且灵活的编程工具。STL的核心概念包括泛型编程、容器、迭代器、算法和函数对象，这些组件共同构成...
C++STL手册.rar
09-23
**C++ STL（Standard Template Library）手册** C++ STL 是 C++ 标准库中的一个核心部分，它提供了一组高效、可重用的容器、算法和迭代器模板类。STL 的设计思想源于泛型编程，使得程序员可以编写与数据类型无关的...
C++ STL详解超全总结(快速入门STL)
热门推荐
行码棋
02-24 14万+
C++STL合集，包含vector，stack，queue，map，set，array，tuple，deque，priority_queue等诸多内容，全文上万字。
C++STL简介
weixin_53811859的博客
03-22 1264
超详细的C++STL简介讲解你值得拥有
C++ STL简介
咸鱼势力登场
04-15 4748
STL的概念 STL的六大组件 STL的缺陷 选择STL容器的基本原则
C++ STL之vector详解
行码棋
01-04 6万+
本文介绍了STL的vector的常用操作以及相关的注意事项
C++STL之map详解
行码棋
09-18 4万+
本文详细介绍map的各种用法和注意事项。
C++ STL 四种智能指针
Dablelv 的博客专栏。
08-07 7万+
auto_ptrunique_ptrshared_ptrweak_ptrauto_ptr 是 C++98 提出的，C++11 已将其摒弃，并提出了 unique_ptr 替代 auto_ptr。虽然 auto_ptr 已被摒弃，但在实际项目中仍可使用，但建议使用更加安全的 unique_ptr，后文会详细叙述。shared_ptr 和 weak_ptr 则是 C+11 从准标准库 Boost 中引入的两种智能指针。
C++ STL常见面试题
kelvin_yin的专栏
12-20 1283
C++常见面试题之STL 30 题
c++ 常用的STL
m0_56053705的博客
03-08 2026
写这篇博客目的是为了记录在刷算法题中使用过的STL，因为有些不太常用的会遗忘。因此这篇博客只是作为笔记，不是详细的STL。此外在后面用到新的STL内容时会再补充。
C++ STL之set详解
行码棋
01-04 2万+
C++ STL之set详解，介绍set的方法及特性
【C++】STL的简介
kdjjdjdjjejje128的博客
10-27 1304
STL的简介
c++ STL模板
11-08
向量vector是一种随机访问的数组类型，提供了对数组元素的快速、随机访问以及在序列尾部快速、随机的插入和删除操作。它是大小可变的向量，在需要是可以改变其大小。 形式：
C++ STL库应用汇总
08-24
知识点四：C++ 中的泛型程序设计 C++ 中的泛型程序设计是指使用模板来编写通用的代码，例如STL中的数据结构和算法都是使用模板实现的。这种方法可以提高代码的可重用性和灵活性。 知识点五：STL的优点 STL 的优点是...
C++ STL 参考手册Cpp_STL_ReferenceManual.pdf
12-21
STL 是 C++ 标准库的一部分，不用单独安装。 C++ 对模板（Template）支持得很好，STL 就是借助模板把常用的数据结构及其算法都实现了一遍，并且做到了数据结构和算法的分离。例如，vector 的底层为顺序表（数组），...
嵌入式初学-C语言-七
最新发布
MaBaB的博客
07-29 527
分支结构 分支结构：又被称之为选择结构 概念 选择结构：根据条件成立与否，选择相应的操作。
背单词工具(C++)
zeyeqianli的博客
07-24 4016
【代码】背单词工具(C++)
C++的STL简介（一）
2302_81171591的博客
07-23 1661
STL（standarf template libaray-标准模板库）：是C++标准库的重要组成部分，不仅是一个可复用的组件库，而且是一个包罗数据结构与算法的软件框架。
C++红黑树
杀意感知的博客
07-25 1154
AVL树：严格平衡（左右子树高度差不超过 1），所以 AVL 树的查找、插入、删除效率高：O(logN)，但在插入和删除节点后，要维持树的平衡状态，做的旋转处理还是很多的。红黑树：近似平衡（控制最长路径不超过最短路径的2倍），变了一种方式来控制树的平衡，相较于 AVL 树而言，没有那么严格。红黑树更多是一种折中的选择，它舍弃平衡二叉树的严格平衡，换取节点插入时尽可能少的调整。因为红黑树的旋转情况少于 AVL 树，使得红黑树整体性能略优于。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

熬夜苦读学习

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值