STL容器之list类

最新推荐文章于 2025-09-01 22:49:35 发布
原创 最新推荐文章于 2025-09-01 22:49:35 发布 · 978 阅读 · 31 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#c++ #list #windows

本文围绕C++ STL容器中的list类展开。介绍了list是由双向链表实现的序列容器，能在任意位置常数时间插入和删除。阐述了其使用方法，包括常见构造、迭代器使用、空间增长、增删查改及迭代器失效问题。还提及了list的模拟实现，难度相对较大。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

文章目录


img

STL容器之list类

1、list的介绍

  • list是序列容器，允许在序列中的任何地方进行常数时间插入和删除操作，以及双向迭代。

  • list容器是由双向链表实现；双向链表可以将它们包含的每个元素存储在不同和不相关的存储位置。在节点中通过指针指向其前一个元素和后一个元素。

  • list与forward_list非常相似：主要区别在于forward_list对象是单链表，只能朝前迭代，以让其更简单高效。

  • 与其他基本标准序列容器（array、vector和deque）相比，list可以在任何位置插入、提取和移动元素方面通常表现更好，因此在密集使用这些元素的算法（如排序算法）中也表现更好。

  • 与这些其他序列容器相比，list和forward_lists的主要缺点是它们无法通过位置直接访问元素；例如，要访问列表中的第六个元素，必须从已知位置（如开始或结束）到该位置，这在它们之间的距离上需要线性时间。它们还消耗一些额外的内存来保存与每个元素相关的链接信息（这可能是大型小元素列表的一个重要因素）。

  • list底层是带头双向循环链表。

2、list的使用

2.1、list的常见构造

(constructor )函数名称接口说明
list (size_type n, const value_type& val = value_type())构造一个长度为n的list，每个元素的值为val
list()构造空的list
list (InputIterator first, InputIterator last)用迭代区间[first,last)构造list
list (const list& x)拷贝构造list
#include <iostream>

#include <list>

using namespace std;

void test_list4(){
    list<int> lt;
    lt.push_back(1);
    lt.push_back(2);
    lt.push_back(3);
    lt.push_back(4);
    lt.push_back(6);

    for (auto e: lt) {
        cout << e << " ";
    }
    cout << endl;

    list<int> lt1(10,2);
    for (auto e: lt1) {
        cout << e << " ";
    }
    cout << endl;

    list<int> lt2(lt1.begin(),lt1.end());
    for (auto e: lt2) {
        cout << e << " ";
    }
    cout << endl;

    list<int> lt3(lt2);
    for (auto e: lt3) {
        cout << e << " ";
    }
    cout << endl;
    
}

int main() {
  
    test_list4();
    return 0;
  
}

2.2、list的iterator的使用

函数名称接口说明
begin()+end()获取第一个元素位置的iterator/const_iterator和获取最后一个元素的后一个位置的iterator/const_iterator
rbegin()+rend()获取最后一个元素位置的reverse_iterator/const_reverse_iterator和获取第一个元素的后一个位置的reverse_iterator/const_reverse_iterator
#include <iostream>

#include <list>

using namespace std;

void test_list5(){
 list<int> lt;
 lt.push_back(1);
    lt.push_back(2);
    lt.push_back(3);
    lt.push_back(4);
    lt.push_back(6);
   
    list<int>::iterator it = lt.begin();
 while(it != lt.end()){
        cout << *it << " ";
        ++it;
    }
    cout <<endl;
   
   
 list<int>::reverse_iterator rit = lt.rbegin();
 while(rit != lt.rend()){
        cout << *rit << " ";
        ++rit;
    }
    cout <<endl;
   }
   
int main() {

 test_list5();
   return 0;
   
   }

2.3、list空间增长问题

函数名称接口说明
empty判断list是否为空
size返回list长度/结点个数
#include <iostream>

#include <list>

using namespace std;

void test_list6() {
    list<int> lt;
    lt.push_back(1);
    lt.push_back(2);
    lt.push_back(3);
    lt.push_back(4);
    lt.push_back(6);

    cout << lt.size() << endl;
    cout << lt.empty() << endl;

    lt.assign(0,0);
    cout << lt.size() << endl;
    cout << lt.empty() << endl;
}

int main() {

 test_list6();
 return 0;

}

2.4、list的增删查改

函数名称接口说明
front
back
push_front
pop_front
push_back
pop_back
insert
erase
swap
clear
#include <iostream>

#include <list>

using namespace std;

void test_list7() {
    list<int> lt;
    lt.push_back(1);
    lt.push_back(2);
    lt.push_back(3);
    lt.push_back(4);
    lt.push_back(6);

    for (auto e: lt) {
        cout << e << " ";
    }
    cout << endl;

    cout << lt.front() << endl;
    cout << lt.back() << endl;

    lt.push_front(10);
    lt.push_back(9);
    for (auto e: lt) {
        cout << e << " ";
    }
    cout << endl;

    lt.pop_front();
    lt.pop_back();
    for (auto e: lt) {
        cout << e << " ";
    }
    cout << endl;

    lt.insert(find(lt.begin(),lt.end(),4),40);
    for (auto e: lt) {
        cout << e << " ";
    }
    cout << endl;

    list<int>::iterator it = lt.erase(find(lt.begin(),lt.end(),6));
    for (auto e: lt) {
        cout << e << " ";
    }
    cout << endl;

    list<int> lt1(10,1);
    swap(lt,lt1);
    for (auto e: lt) {
        cout << e << " ";
    }
    cout << endl;

    for (auto e: lt1) {
        cout << e << " ";
    }
    cout << endl;

    lt.clear();
    for (auto e: lt) {
        cout << e << " ";
    }
    cout << endl;

}

int main() {

 test_list7();
 return 0;

}

2.5、list迭代器失效问题

  • list迭代器的主要作用就是让算法能够不用关心底层数据结构，其底层实际是对指针进行了封装。

  • 迭代器失效即迭代器所指向的节点的无效，即该节点被删除了。

  • 因为list的底层结构为带头结点的双向循环链表，因此在list中进行插入时是不会导致list的迭代器失效的，只有在删除时才会失效，并且失效的只是指向被删除节点的迭代器，其他迭代器不会受到影响。

    void TestListIterator1()
{
    int array[] = { 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 = l.erase(it);
        ++it;// 每次跳一个删除
    }
}

3、list的模拟实现（含反向迭代器）

注意：list的模拟实现用到了比较多的模版，同时还用到了组合（其中之一就是反向迭代器的实现），相对于string和vector的模拟实现会更难。

  • vector.h文件

    //
// Created by 徐鹏 on 2023/12/10.
//
  
#include <iostream>
#include <cstdio>
#include <cstring>
#include <list>
  
#include "ReverseIterator.h"
  
using namespace std;
  
#ifndef DEMO_01_VECTOR_H
#define DEMO_01_VECTOR_H
  
#endif //DEMO_01_VECTOR_H
  
namespace xp {
    template<typename T>
    class vector {
    public:
        typedef T *iterator;
        typedef const T *const_iterator;
  
        typedef ReverseIterator<iterator, T &, T *> reverse_iterator;
        typedef ReverseIterator<const_iterator, const T &, const T *> const_reverse_iterator;


        vector() : _start(nullptr), _finish(nullptr), _end_of_storage(nullptr) {}

//        vector(const vector<T> &v) {
//            _start = new T[v.capacity()];
//            memcpy(_start, v._start, v.size() * sizeof(T));
//            _finish = _start + v.size();
//            _end_of_storage = _start + capacity();
//        }

        //拷贝构造函数
        vector(const vector<T> &v) {
            reserve(v.capacity());
            for (const auto &e: v) {
                push_back(e);
            }
        }
    
        template<class InputIterator>
        //构造迭代器区间
        vector(InputIterator first, InputIterator last) {
            while (first != last) {
                push_back(*first);
                ++first;
            }
        }
    
        vector(size_t n, const T &val = T()) {
            resize(n, val);
        }
    
        //防止和上面迭代器区间搞混
        vector(int n, const T &val = T()) {
            resize(n, val);
        }
    
        //赋值 ,这里vector<T> v在传值的时候就已经有拷贝构造了
        vector<T> &operator=(vector<T> v) {
            swap(v);
            return *this;
        }
    
        T &operator[](size_t n) {
            return *(_start + n);
        }
    
        const T &operator[](size_t n) const {
            return *(_start + n);
        }
    
        ~vector() {
            if (_start) {
                delete[] _start;
                _start = _finish = _end_of_storage = nullptr;
            }
        }
    
        void swap(vector<T> v) {
            std::swap(_start, v._start);
            std::swap(_finish, v._finish);
            std::swap(_end_of_storage, v._end_of_storage);
        }
    
        void reserve(size_t n) {
            if (n > capacity()) {
                //开辟新空间
                size_t old_size = size();
                iterator tmp = new T[n];
                //start不为空，在复制完内容需要释放空间
                if (_start) {
//                    //对于自定义类型，在进行delete[] _start 之后（自定义类型里面存在指针开辟空间问题的时候），会把原来的_start里面内容进行析构和空间释放
//                    memcpy(tmp, _start, old_size * sizeof(T));

                    //  解决方案，进行深拷贝
                    for (size_t i = 0; i < old_size; ++i) {
                        tmp[i] = _start[i];
                    }
                    delete[] _start;
                }
                _start = tmp;
                //这里要注意，得用之前的size，不然新size使用内联进来就是_finish = _start + _finish - _start
                _finish = _start + old_size;
                _end_of_storage = _start + n;
            }
        }
    
        void resize(size_t n, T val = T()) {
            if (n > capacity()) {
                size_t fill = _start + n - _finish;
                reserve(n);
                //填补之前finish后面fill个数据
                while (fill != 0) {
                    *_finish = val;
                    _finish++;
                    fill--;
                }
            }
        }
    
        void push_back(const T &val) {
            if (_finish == _end_of_storage) {
                size_t newCapacity = capacity() == 0 ? 4 : 2 * capacity();
                reserve(newCapacity);
            }
            *_finish = val;
            ++_finish;
        }
    
        void pop_back() {
            --_finish;
        }
    
        void insert(iterator pos, const T &val) {
            assert(pos >= _start);
            assert(pos <= _finish);
    
            if (_finish == _end_of_storage) {
                size_t len = pos - _start;
                size_t newCapacity = capacity() == 0 ? 4 : 2 * capacity();
                reserve(newCapacity);
                pos = _start + len;//防止增容量后，pos位置还是之前被释放的空间
            }
            //memmove(pos + 1, pos, sizeof(T) * (_finish - pos)); //浅拷贝，扩容可能存在迭代器失效问题
            iterator end = _finish - 1;
            while (pos <= end) {
                *(end + 1) = *end;
                --end;
            }
            *pos = val;
            ++_finish;
        }
    
        iterator begin() {
            return _start;
        }
    
        const_iterator begin() const {
            return _start;
        }
    
        iterator end() {
            return _finish;
        }
    
        const_iterator end() const {
            return _finish;
        }
    
        reverse_iterator rbegin() {
            return end();
        }
    
        const_reverse_iterator rbegin() const {
            return end();
        }
    
        reverse_iterator rend() {
            return begin();
        }
    
        const_reverse_iterator rend() const{
            return begin();
        }


        size_t size() const {
            return _finish - _start;
        }
    
        size_t capacity() const {
            return _end_of_storage - _start;
        }
    
    private:
        iterator _start = nullptr;
        iterator _finish = nullptr;
        iterator _end_of_storage = nullptr;
    };
    
    void test_vector1() {
        vector<char> v;
        v.reserve(10);
        cout << v.size() << " " << v.capacity() << endl;
//        v.resize(100);
        v.resize(100, 'x');
        cout << v.size() << " " << v.capacity() << endl;

    }
    
    void test_vector2() {
        vector<int> v;
        v.push_back(1);
        v.push_back(2);
        v.push_back(3);
        v.push_back(4);
        v.push_back(5);
        for (auto e: v) {
            cout << e << " ";
        }
        cout << endl;
    }
    
    void test_vector3() {
        vector<string> v;
        v.push_back("hh");
        v.insert(v.begin(), "2");
        v.insert(v.begin(), "2");
        v.insert(v.begin(), "2");
        v.insert(v.begin(), "2");
        v.insert(v.begin(), "2");
        v.insert(v.begin(), "2");
        v.insert(v.begin(), "2");
        v.insert(v.begin(), "2");
        for (auto e: v) {
            cout << e << " ";
        }
        cout << endl;
    }
    
    void test_vector4() {
        vector<string> v1;
        v1.push_back("hhh");
        v1.push_back("www");
        for (auto e: v1) {
            cout << e << " ";
        }
        cout << endl;
    
        vector<string> v2;
        v2.push_back("lllll");
        v2.push_back("nnnnn");
        for (auto e: v2) {
            cout << e << " ";
        }
        cout << endl;
        cout << "----------------------" << endl;
        v1 = v2;
        for (auto e: v1) {
            cout << e << " ";
        }
        cout << endl;
        for (auto e: v2) {
            cout << e << " ";
        }
        cout << endl;
    
    }
    
    void test_vector5() {
        vector<string> v;
        v.push_back("w");
        v.push_back("s");
        v.push_back("x");
        v.push_back("p");
        cout << v[1] << endl;
    }
    
    void test_vector6() {
        vector<string> v;
        v.push_back("w");
        v.push_back("s");
        v.push_back("x");
        v.push_back("p");
        v.push_back("p");
        v.push_back("p");
        v.push_back("p");
        v.push_back("p");
        v.push_back("psdf");
        v.push_back("pdsf");
        v.push_back("pfd");
        v.push_back("pdsf");
        v.insert(v.begin(), "sdas");
        for (auto e: v) {
            cout << e << " ";
        }
        cout << endl;
    }
    
    void test_vector7() {
        vector<string> v;
        v.push_back("w");
        v.push_back("s");
        v.push_back("x");
        v.push_back("p");
        v.push_back("p");
        v.push_back("p");
        vector<string> v2(v.begin(), v.end());
        for (auto e: v2) {
            cout << e << " ";
        }
        cout << endl;
    
        int a[] = {1111, 222, 222, 3};
        vector<int> v3(a, a + 4);
        for (auto e: v3) {
            cout << e << " ";
        }
        cout << endl;
    
        list<string> lt;
        lt.push_back("hjakds");
        lt.push_back("wq");
        lt.push_back("qw");
        lt.push_back("w");
    
        vector<string> v4(lt.begin(), lt.end());
        for (auto e: v4) {
            cout << e << " ";
        }
        cout << endl;
    
        vector<int> v5(5, 5);
        for (auto e: v5) {
            cout << e << " ";
        }
        cout << endl;
    }
    
    void test_vector8() {
        vector<int> v;
        v.push_back(1);
        v.push_back(2);
        v.push_back(3);
        v.push_back(4);
        v.push_back(5);
    
        vector<int>::reverse_iterator rit = v.rbegin();
        while (rit != v.rend()) {
            cout << *rit << " ";
            rit++;
        }
        cout << endl;
    }

}

  • list.h文件

    //
// Created by 徐鹏 on 2024/3/3.
//

#ifndef DEMO_05_LIST_H
#define DEMO_05_LIST_H

#endif //DEMO_05_LIST_H

#include "ReverseIterator.h"
#include <iostream>

using namespace std;


// list的模拟实现(还未完成)

namespace xp {

    // 结点
    template<class T>
    struct ListNode {
        ListNode<T> *_next;
        ListNode<T> *_prev;
        T data;

        // 构造函数  -- 创建结点
        ListNode(const T val = T()) : _next(nullptr), _prev(nullptr), data(val) {

        }
    };

    template<class T, class Ref, class Ptr>
    class __list_iterator {
    public:
        typedef ListNode<T> Node;
        typedef __list_iterator<T, Ref, Ptr> self; // 迭代器本身

        // 这里构造函数为了方便begin和end，直接隐式类型转换
        __list_iterator(Node *node) : _node(node) {

        }

        Ref operator*() {
            return _node->data;
        }

        Ptr operator->() {
            return &_node->data;
        }

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

        self operator++(int) {
            self temp(*this); // 这里*this的类型是self ,调用默认拷贝构造函数！因为是内置类型，不需要自己写
            _node = _node->_next;
            return temp;
        }

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

        self &operator--(int) {
            self temp(*this);
            _node = _node->_prev;
            return temp;
        }

        bool operator!=(const self &s) {
            return _node != s._node;
        }

        bool operator==(const self &s) {
            return _node == s._node;
        }

        // 拷贝构造和析构不需要写，析构不能用，不然结点被删除了

        // 比如 lt.begin()，这里的类型就是Node*
        Node *_node; // 内置类型不能重载++等操作符，因此对这个内置类型进行封装来实现++等功能
    };

//    template<class T>
//    class __list_const_iterator {
//    public:
//        typedef ListNode<T> Node;
//        typedef __list_const_iterator<T> self; // 迭代器本身
//
//        // 这里构造函数为了方便begin和end，直接隐式类型转换
//        __list_const_iterator(Node *node) : _node(node) {
//
//        }
//
//        const T &operator*() {
//            return _node->data;
//        }
//
//        self &operator++() {
//            _node = _node->_next;
//            return *this;
//        }
//
//        self operator++(int) {
//            self temp(*this); // 这里*this的类型是self ,调用默认拷贝构造函数！因为是内置类型，不需要自己写
//            _node = _node->_next;
//            return temp;
//        }
//
//        self &operator--() {
//            _node = _node->_prev;
//            return *this;
//        }
//
//        self &operator--(int) {
//            self temp(*this);
//            _node = _node->_prev;
//            return temp;
//        }
//
//        bool operator!=(const self &s) {
//            return _node != s._node;
//        }
//
//        bool operator==(const self &s) {
//            return _node == s._node;
//        }
//
//        // 拷贝构造和析构不需要写，析构不能用，不然结点被删除了
//
//        // 比如 lt.begin()，这里的类型就是Node*
//        Node *_node; // 内置类型不能重载++等操作符，因此对这个内置类型进行封装来实现++等功能
//    };

    template<class T>
    class list {
    public:
        typedef ListNode<T> Node;
        typedef __list_iterator<T, T &, T *> iterator;
        typedef __list_iterator<T, const T &, const T *> const_iterator;

        typedef ReverseIterator<iterator, const T &, const T *> reverse_iterator;
        typedef ReverseIterator<const_iterator, const T &, const T *> const_reverse_iterator;

        //构造函数
        list() {
            //创建带头节点的双向循环链表
            _head = new Node;
            _head->_next = _head;
            _head->_prev = _head;
        }

        // 拷贝构造函数
        list(list<T> &lt) {
            // 先创个头节点
            _head = new Node;
            _head->_next = _head;
            _head->_prev = _head;

            iterator it = lt.begin();
            while (it != lt.end()) {
                push_back(*it);
                ++it;
            }
        }

        void swap(list<T> &lt) {
            std::swap(_head, lt._head);
        }

        // 赋值
        list<T> operator=(list<T> lt) {
            swap(lt);
            return *this;
        }

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

        iterator end() {
            return _head;
        }

        const_iterator begin() const {
            return _head->_next;
        }

        const_iterator end() const {
            return _head;
        }

        reverse_iterator rbegin() {
            return end();
        }

        reverse_iterator rend() {
            return begin();
        }

        const_reverse_iterator rbegin() const {
            return end();
        }

        const_reverse_iterator rend() const {
            return begin();
        }

        void push_back(const T &val) {
//            Node *tail = _head->_prev;// 先找到尾
//
//            // 创建新节点
//            Node *newnode = new Node(val);
//
//            tail->_next = newnode;
//            newnode->_prev = tail;
//
//            newnode->_next = _head;
//            _head->_prev = newnode;

            insert(end(), val);
        }

        iterator insert(iterator pos, const T &val) {

            Node *cur = pos._node;
            Node *prev = cur->_prev;
            Node *newnode = new Node(val);

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

            return newnode;
        }

        iterator erase(iterator pos) {
            assert(pos != _head);// _head这个位置就是end()

            Node *cur = pos._node;
            Node *prev = cur->_prev;
            Node *tail = cur->_next;

            prev->_next = tail;
            tail->_prev = prev;

            delete cur;

            return tail;
        }

        void clear() {
            // 清空所有数据，只留一个头节点
            iterator it = begin();
            while (it != end()) {
                it = erase(begin());
            }
        }

        ~list() {
            clear();
            if (_head) {
                delete _head;
                _head = nullptr;
            }

        }

    private:
        Node *_head;// 头节点 -- 带头双向循环链表
    };

    void test_list1() {
        list<int> lt;
        lt.push_back(1);
        lt.push_back(2);
        lt.push_back(3);
        lt.push_back(4);
        lt.push_back(5);

        list<int>::iterator it = lt.begin();
        while (it != lt.end()) {
            cout << *it << " ";
            it++;
        }
        cout << endl;

        lt.insert(lt.begin(), 10);
        lt.insert(lt.begin(), 20);
        lt.insert(lt.begin(), 30);

        for (auto e: lt) {
            cout << e << " ";
        }
        cout << endl;

        lt.erase(--lt.end());
        lt.erase(--lt.end());
        for (auto e: lt) {
            cout << e << " ";
        }
        cout << endl;

        lt.clear();
        for (auto e: lt) {
            cout << e << " ";
        }
        cout << endl;
    }

    void test_list2() {
        list<int> lt;
        lt.push_back(1);
        lt.push_back(2);
        lt.push_back(3);
        lt.push_back(4);
        lt.push_back(5);

        list<int> lt1(lt);
        for (auto e: lt1) {
            cout << e << " ";
        }
        cout << endl;

        list<int> lt2 = lt;
        for (auto e: lt2) {
            cout << e << " ";
        }
        cout << endl;
    }


    //  测试const迭代器
    void Print_list(const list<int> &lt) {
        list<int>::const_iterator it = lt.begin();

        while (it != lt.end()) {
            cout << *it << " ";
            ++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);
        lt.push_back(5);

        for (auto e: lt) {
            cout << e << " ";
        }
        cout << endl;

        Print_list(lt);
    }


    // 测试list重载->运算符
    struct AA {
        AA(int a1 = 3, int a2 = 4) : _a1(a1), _a2(a2) {

        }

        int _a1 = 1;
        int _a2 = 2;
    };

    void test_list4() {
        list<AA> lt;
        lt.push_back(AA());
        lt.push_back(AA(2, 1));
        lt.push_back(AA(5, 5));

        list<AA>::iterator it = lt.begin();
        while (it != lt.end()) {
            cout << (*it)._a1 << " " << (*it)._a2 << endl;
            cout << it->_a1 << " " << it->_a2 << endl;
            cout << it.operator->()->_a1 << " " << it.operator->()->_a2 << endl;//原型，即运算符重载->省略了一个->
            ++it;
        }
    }

    void test_list5() {
        list<int> lt;
        lt.push_back(1);
        lt.push_back(2);
        lt.push_back(3);
        lt.push_back(4);
        lt.push_back(5);

        list<int>::reverse_iterator rit = lt.rbegin();
        while (rit != lt.rend()) {
            cout << *rit << " ";
            ++rit;
        }
        cout << endl;
    }
}

  • ReverseIterator.h文件

    //
// Created by 徐鹏 on 2024/3/11.
//
  
#ifndef DEMO_05_REVERSEITERATOR_H
#define DEMO_05_REVERSEITERATOR_H
  
#endif //DEMO_05_REVERSEITERATOR_H


template<class Iterator, class Ref, class Ptr>
struct ReverseIterator {
    typedef ReverseIterator<Iterator, Ref, Ptr> self;

    ReverseIterator(Iterator it) : _it(it) {
    
    }


    // 这里我们采用和正向迭代器对称的结构
    Iterator _it;
    
    Ref operator*() {
        Iterator tmp = _it;// 不能改变_it的位置，用tmp来指向_it的位置，来改变tmp的位置
        --tmp;
        return *tmp;
    }
    
    Ptr operator->() {
        return &(operator*());
    }
    
    self &operator++() {
        --_it;
        return *this;
    }
    
    self operator++(int) {
        self tmp(*this);
        --_it;
        return tmp;
    }
    
    self &operator--() {
        ++_it;
        return *this;
    }
    
    self operator--(int) {
        self tmp(*this);
        ++_it;
        return tmp;
    }
    
    bool operator!=(const self &s) {
        return _it != s._it;
    }
    
    bool operator==(const self &s) {
        return _it == s._it;
    }
};

  • main.cpp文件

    #include "list.h"

int main() {
//    xp::test_list1();
//    xp::test_list2();
//    xp::test_list3();
//    xp::test_list4();
    xp::test_list5();
    return 0;
}

OKOK，C++ STL容器之list类就到这里。如果你对Linux和C++也感兴趣的话，可以看看我的主页哦。下面是我的github主页，里面记录了我的学习代码和leetcode的一些题的题解，有兴趣的可以看看。

Xpccccc的github主页

C++STL容器详解——list
未知陨落的博客
11-06 1271
list是可以在常数范围内在任意位置进行插入和删除的序列式容器，并且该容器可以前后双向迭代
C++ STL容器之list链表
weixin_63162063的博客
07-02 1693
splice(iterator Where,list& Right,iterator First,iterator Last)：将。构建了指定长度的链表,并且有默认的初始值。链表是序列性容器的模板类，它将其元素保持在线性排列中，链式结构，并允许在序列中的任何位置进行有效的插入和删除。//构建了指定长度的链表,并且有默认的初始值。//构建了指定长度的链表,手动指定初始值。返回链表的长度、元素的数量。
STL之容器list
热门推荐
Serven的博客
04-25 1万+
STL容器之list
C++的STL容器类详解
Jinyizhi2233的博客
07-11 4368
STL（Standard Template Library）是C++标准库中的一个重要组成部分，它提供了一组通用的模板类和函数，用于实现常用的数据结构和算法。（Containers）：STL提供了多种容器类，如向量（vector）、链表（list）、双向链表（deque）、集合（set）、映射（map）等。总而言之，STL是C++开发中非常重要的工具之一，它提供了高效的数据结构和算法，能够提高程序的性能、减少开发时间，并提高代码的重用性和可维护性。这样可以大大提高代码的重用性，减少了开发时间和维护成本。
STL容器详解（C++）
weixin_46571171的博客
09-29 1780
C++中的STL容器详解，详细说明容器的底层原理、数据结构以及常用方法。
C++ : STL容器之list剖析
2301_81454749的博客
10-21 2019
stl容器：双向循环链表list剖析
C++ STL常用容器之deque&list
炸酱面鸡腿
12-11 1436
对于STL中deque和list序列式容器用法进行了说明和介绍
STL常用容器—list容器（链表）
weixin_46216674的博客
02-03 2144
整理总结C++ STL中list常用容器，主要实现对链表的基本操作，包括增删改查以及翻转、排序等常见操作
STL容器
Edward2022的博客
01-28 1087
C++之STL容器
C++ STL--list容器
积木的笔记
12-08 1943
C++ STL--list容器介绍
C++实现STL容器之List
12-22
C++实现STL容器之List。内容来源于网络分享，如有侵权请联系我删除。另外如果没有积分的同学需要下载，请私信我。
C++系列-STL容器之list
weixin_48668114的博客
08-31 1358
C++系列-STL容器之list
第8篇c++Expression: (L“Buffer is too small“ && 0
最新发布
Txwtech
09-01 100
C#调用C++库时出现缓冲区断言错误，原因是使用了不安全的strcpy_s函数。问题出在计算缓冲区大小时错误地使用了sizeof(charArr)而不是实际需要的str_data.length()+1。解决方案有两种：1）改用普通的strcpy函数；2）在预处理器中添加_CRT_SECURE_NO_WARNINGS宏定义来禁用安全检查。修复后的代码正确分配了足够空间并使用strcpy进行字符串复制，避免了缓冲区溢出问题。该错误属于C++与C#互操作时的常见内存管理问题。
【C++】内存管理机制：从new到delete全解析
leilei050213的博客
09-01 1019
C++在保留C语言内存管理方式的基础上，引入了更安全高效的new/delete机制。相比C语言方式，new/delete优势在于：符合面向对象思想（定义即初始化）、代码更简洁、更安全。
C++ 枚举算法详细利用与数字分解教学教案
m0_46324731的博客
08-31 587
解析：分解出各位数字后，使用逻辑与 (&&) 运算符检查 "百位 > 十位" 且 "十位 > 个位" 的条件，满足则计数器加 1。编写程序，统计 100-999 之间所有满足 "百位数字大于十位数字，且十位数字大于个位数字" 的三位数的个数。解析：以 4567 为例，4567 / 100 = 45，45 % 10 = 5，得到百位数字。解析：通过 i%10 获取个位数字，判断是否等于 5，若是则计数器加 1，最终输出总数。解析：456 % 100 = 56，56 / 10 = 5，得到十位数字。
【C++】什么是智能指针及应用
梁同学与Android
09-01 361
智能指针是C++中管理动态内存的重要工具，能有效避免内存泄漏。必须使用智能指针的三种场景：1）动态分配的内存（new创建对象）；2）需要在多个地方共享的内存；3）函数返回动态分配的对象。不需要使用智能指针的情况：1）栈上对象；2）全局/静态变量；3）已由其他系统管理的内存。核心原则：只要写了new就必须用智能指针，智能指针的价值在于自动管理内存释放，减少人为错误，提升代码安全性。
GCC版本和C语言标准版本的对应关系
jongden的专栏
08-28 506
以下是GCC版本与C语言标准支持情况的对应关系表格，涵盖主要版本的显式支持选项及默认C标准（含GNU扩展）：​​​​​​​​C89（部分支持）无明确默认（接近C89）早期版本对C89支持不完整，仅实现基础特性。C89（完全支持）、C99（部分特性）gnu89（C89 + GNU扩展）开始支持C99的基础特性（如//注释），但复杂特性（如变长数组、复数类型）未完全实现。C89、C99（完全支持）、C11（实验性，-std=c11gnu89正式完成C99核心特性支持（如long long。
《C++ Primer 第五版》默认实参初始值
dlz0836的博客
08-28 373
名字解析：在函数声明处完成，决定默认参数“绑定到哪个变量/函数”。表达式求值：在函数调用处发生，用的是绑定对象的当前值。局部同名变量不会改变默认参数绑定，因为解析已经固定在声明处的作用域。📌 所以看到的现象：改变def（全局变量） → 默认实参生效变化定义局部wd（只是隐藏了全局 wd） → 默认实参依然用全局的 80。
C++_继承
qjworkman的博客
09-01 105
继承允许我们定义一个新类（称为派生类或子类），它基于一个已有的类（称为基类或父类）。继承、封装和多态共同构成了C++面向对象编程的基石，使我们能够构建模块化、可复用、易于维护的复杂软件系统。目的：实现代码复用、建立类的层次结构、为多态打下基础。继承方式 (Inheritance Modes)多态 (Polymorphism) 的体现。面向对象编程 (OOP) 的三大支柱。继承为多态提供了基础。继承是连接封装和多态的桥梁。
C++ STL list容器使用与总结
C++标准模板库（Standard Template Library，STL）是C++语言的核心库之一，它提供了大量容器、迭代器、算法、函数对象等组件，极大地丰富了C++编程的工具箱。在STL众多组件中，list是一个双向链表容器，它允许在序列...
评论 7
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

Xpccccc

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

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

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

打赏作者

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

抵扣说明：

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

余额充值