STL容器——list

最新推荐文章于 2024-02-03 19:38:44 发布
最新推荐文章于 2024-02-03 19:38:44 发布
阅读量315 收藏
点赞数
分类专栏： STL 文章标签： c++ list 链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lyzzs222/article/details/126720169
版权

文章目录


前言：list是带头节点的双向循环链表，本文意在了解list的基本使用，并且模拟实现list。

1.list的基本框架

list是由一个一个的节点，形成的双向带头链表，所以必须实现节点这一结构。

    template<class T>
    struct ListNode
    {
        //节点的构造函数
        ListNode(const T& val = T())
            :_pNext(nullptr),
            _pPre(nullptr),
            _val(val)
        {
        }
       //指向前面节点的指针
        ListNode<T>* _pPre;
       //指向后面节点的指针
        ListNode<T>* _pNext;
       //节点的数据
        T _val;
    };

在这里插入图片描述
有了节点，再对节点进行链接，就形成了链表。链表中只需要有头节点就可以通过头节点找到其他的节点。

class list
 {
   typedef ListNode<T> Node;
   typedef Node* PNode;
 private:
   PNode _pHead;
 }

实现构造函数，只创造头节点，至于后面的节点插入就好了

        list()
        {
            _pHead = new Node;
            _pHead->_pNext = _pHead;
            _pHead->_pPre = _pHead;
        }

实现push_back()，插入数据

        void push_back(const T& val)
        {
             //创建新的节点
            PNode newnode = new Node(val);
            //保存尾节点
            PNode tail = _pHead->_pPre;
            //进行链接
            _pHead->_pPre = newnode;
            tail->_pNext = newnode;
            newnode->_pNext = _pHead;
            newnode->_pPre = tail;
        }

这就是最简易的list实现。

namespace ly
{   
    //list的节点
    template<class T>
    struct ListNode
    {   
        //节点的构造函数
        ListNode(const T& val = T())
            :_pNext(nullptr),
            _pPre(nullptr),
            _val(val)
        {
        }
       //指向前面节点的指针
        ListNode<T>* _pPre;
       //指向后面节点的指针
        ListNode<T>* _pNext;
       //节点的数据
        T _val;
    };
  template<class T>
  class list
 {
   typedef ListNode<T> Node;
   typedef Node* PNode;
 public:
     //构造函数
        list()
        {
            _pHead = new Node;
            _pHead->_pNext = _pHead;
            _pHead->_pPre = _pHead;
        }
     //插入节点
       void push_back(const T& val)
        {
             //创建新的节点
            PNode newnode = new Node(val);
            //保存尾节点
            PNode tail = _pHead->_pPre;
            //进行链接
            _pHead->_pPre = newnode;
            tail->_pNext = newnode;
            newnode->_pNext = _pHead;
            newnode->_pPre = tail;
        }
 private:
   PNode _pHead;
 }
 
 }

2.list的具体模拟实现

上述的list功能和STL中的list相差甚远，所以我们需要进一步的完善我们的list。

2.1 list的迭代器实现

vector和string的迭代器是封装的指针，因为它俩是顺序储存，物理地址挨着，所以迭代器的实现和操作都非常的简单。但是list的迭代器呢？它由于物理空间不连续，用指针，将链表串联起来，不支持随机访问。该如何实现它的迭代器呢？这个迭代器如何进行++，解引用等操作呢？
答案是：我们可以创建一个迭代器类，在类中实现迭代器的功能，我们可以重载运算符，对吧？

2.1.1 简易迭代器实现

实现一个简易的迭代器，完成++到下一个节点的功能，以及解引用。

template<class T>
class ListIterator
{
  typedef ListNode<T>* PNode;
  typedef ListIterator<T> Self;
  public:
  //迭代器
  PNode _pNode;
  //迭代器构造
        ListIterator(PNode pNode = nullptr)
            :_pNode(pNode)
        {
        }
  //迭代器++，--
       //前置++
       Self& operator++()
        {

            _pNode = _pNode->_pNext;
            return *this;
        }
       //后置++
        Self operator++(int)
        {
            Self tmp(*this);
            _pNode = _pNode->_pNext;
            return tmp;
        }

        Self& operator--()
        {
            _pNode = _pNode->_pPre;
            return *this;
        }
        
        Self operator--(int)
        {
            Self tmp(*this);
            _pNode = _pNode->_pPre;
            return tmp;
        }
  //迭代器解引用
        Ref operator*()
        {
            return _pNode->_val;
        }   
};
2.1.2 如何支持const版本的迭代器

但是上述的迭代器，如果想要支持const版本的，该如何实现呢？
可能有人说，这不难，我直接再写一个迭代器就好了，里面全换成支持const调用的版本就好了，这个方法可以，但是不要忘了模板参数这个东东。

template<class T，class Ref>
class ListIterator
{
  typedef ListNode<T>* PNode;
  typedef ListIterator<T,Ref> Self;
  public:
  //迭代器
  PNode _pNode;
  //迭代器构造
        ListIterator(PNode pNode = nullptr)
            :_pNode(pNode)
        {
        }
  //迭代器++，--
       //前置++
       Self& operator++()
        {

            _pNode = _pNode->_pNext;
            return *this;
        }
       //后置++
        Self operator++(int)
        {
            Self tmp(*this);
            _pNode = _pNode->_pNext;
            return tmp;
        }

        Self& operator--()
        {
            _pNode = _pNode->_pPre;
            return *this;
        }
        
        Self operator--(int)
        {
            Self tmp(*this);
            _pNode = _pNode->_pPre;
            return tmp;
        }
  //迭代器解引用
        Ref operator*()
        {
            return _pNode->_val;
        }   
};

昂这样就可以了？就改个模板参数？答案是：就是这样，改模板参数，具体使用时，直接对应推导即可。
比如：

        typedef ListIterator<T, T&> iterator;
        typedef ListIterator<T, const T&> const_iterator;

这样就已经，完成了两个版本。

2.1.3 完整的迭代器

迭代器也是支持 ->，同样也得支持const版本，所以再添加一个模板参数。总共就是三个参数，查看STL源码时，当然也是三个模板参数。

        typedef ListIterator<T, T&,T*> iterator;
        typedef ListIterator<T, const T&,const T*> const_iterator;

    template<class T, class Ref, class Ptr>
    class ListIterator
    {
        typedef ListNode<T>* PNode;

        typedef ListIterator<T, Ref, Ptr> Self;

    public:

        ListIterator(PNode pNode = nullptr)
            :_pNode(pNode)
        {
        }
        Ref operator*()
        {
            return _pNode->_val;
        }

        Ptr operator->()
        {
            return &_pNode->_val;
        }

        Self& operator++()
        {

            _pNode = _pNode->_pNext;
            return *this;
        }

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

        Self& operator--()
        {
            _pNode = _pNode->_pPre;
            return *this;
        }

        Self operator--(int)
        {
            Self tmp(*this);
            _pNode = _pNode->_pPre;
            return tmp;
        }

        bool operator!=(const Self& it)
        {
            return _pNode != it._pNode;
        }

        bool operator==(const Self& it)
        {
            return _pNode == it._pNode;
        }
        PNode _pNode;
    };

关于以上对->重载，大家可能有疑惑？为什么返回的是一个T*，或者是一个const T*。
也就是说我们调用 iterator it->，返回的是一个指针，所以还得加一个->才能达到我们想要的结果，但是由于这样的可读性比较差，所以编译器做了优化，并不需要额外添加->。

2.2 list的构造函数

每个list都有一个哨兵位头节点，所以我们写一个创造头节点的函数

        void CreateHead()
        {
            _pHead = new Node();
            _pHead->_pNext = _pHead;
            _pHead->_pPre = _pHead;
        }
2.2.1 list构造函数
        //无参的构造，只创造头节点
        //这里直接复用CreatHead()也可以
        list()
        {
            _pHead = new Node;
            _pHead->_pNext = _pHead;
            _pHead->_pPre = _pHead;
        }
        //构造list含有n个节点且节点的val为value
        list(int n, const T& value = T())
        {   
            //创造头节点
            CreateHead();
            for (int i = 0; i < n; i++)
            {
                push_back(value);
            }
        }
        //根据迭代器的区间，初始化list
        template <class Iterator>
        list(Iterator first, Iterator last)
        {   
            CreateHead();
            while (first != last)
            {
                push_back(*first);
                ++first;
            }
        }
2.2.2 list的拷贝构造以及=的重载
       list(const list<T>& it)
        {
            CreateHead();
            list<T> tmp(it.begin(), it.end());
            std::swap(_pHead, tmp._pHead);
        }
        
        list<T>& operator=(list<T> it)
        {

            std::swap(_pHead, it._pHead);
            return *this;
        }

拷贝构造的话，直接创建一个临时的list tmp去拷贝 it 的所有节点值，再和this交换头节点就可以了。
赋值重载，用的传值传参，所以直接交换 it 的头节点即可。

2.2.3 迭代器功能实现
        typedef ListIterator<T, T&,T*> iterator;
        typedef ListIterator<T, const T&,const T*> const_iterator;
        iterator begin()
        {
            return iterator(_pHead->_pNext);
        }

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

        const_iterator begin() const
        {
            return const_iterator(_pHead->_pNext);
        }

        const_iterator end() const
        {
            return const_iterator(_pHead);
        }
2.2.4 插入和删除操作


        // 在pos位置前插入值为val的节点

        iterator insert(iterator pos, const T& val)
        {
            PNode newnode = new Node(val);
            PNode cur = pos._pNode;
            PNode pre = cur->_pPre;

            cur->_pPre = newnode;
            newnode->_pNext = cur;
            pre->_pNext = newnode;
            newnode->_pPre = pre;

            return iterator(newnode);
        }

         删除pos位置的节点，返回该节点的下一个位置

        iterator erase(iterator pos)
        {
            PNode next = pos._pNode->_pNext;
            PNode pre = pos._pNode->_pPre;
            pre->_pNext = next;
            next->_pPre = pre;
            delete pos._pNode;
            return iterator(next);
        }
         全部复用上面的即可
        //尾插
         void push_back(const T& val)
        {
           /*PNode newnode = new Node(val);
            PNode tail = _pHead->_pPre;
            _pHead->_pPre = newnode;
            tail->_pNext = newnode;
            newnode->_pNext = _pHead;
            newnode->_pPre = tail;*/
           insert(end(), val);
        }
        //尾删
        void pop_back()
        {
            erase(end());
        }
        //头插
        void push_front(const T& val)
        {
            insert(begin(), val);
        }
        //头删
        void pop_front()
        {
            erase(begin());
        }

上面的所有功能都可以复用insert和erase，从这里直观的看出list的插入删除非常高效，只需要改变一下节点的指向关系，就能完成插入，删除，灰常强势。

2.2.5 析构函数

清理资源的话，我们希望实现两种：一种可以清除除了头节点的所有其它节点，另一种则是完成的释放list的所有节点。

       //不清除头节点
        void clear()
        { 
            iterator it = begin();
            while (it != end())
            {
                erase(it++);
            }
        }
        //析构函数
         void clear()
        { 
            iterator it = begin();
            while (it != end())
            {
                erase(it++);
            }
        }
2.2.6 其他功能
       size_t size() const
        {
            size_t i = 0;
            const_iterator it = begin();
            while (it != end())
            {
                i++;
                it++;
            }
            return i;
        }

        bool empty()const
        {
            return _pHead->_pNext == _pHead->_pPre;
        }
         T& front()
        {
            return * begin();
        }

        const T& front()const
        {
            return *begin();
        }

        T& back()
        {
            return *(--end());
        }

        const T& back()const
        {
            return *(--end());
        }
        
        void Print()
        {
            for (auto it : *this)
            {
                std::cout << it << ' ';
            }
            std::cout << std::endl;
        }

3. list模拟实现代码

#include<iostream>
namespace ly
{
    // List的节点类
    template<class T>
    struct ListNode
    {

        ListNode(const T& val = T())
            :_pNext(nullptr),
            _pPre(nullptr),
            _val(val)
        {
        }

        ListNode<T>* _pPre;

        ListNode<T>* _pNext;

        T _val;
    };
    //List的迭代器类
    template<class T, class Ref, class Ptr>
    class ListIterator
    {
        typedef ListNode<T>* PNode;

        typedef ListIterator<T, Ref, Ptr> Self;

    public:

        ListIterator(PNode pNode = nullptr)
            :_pNode(pNode)
        {
        }
        Ref operator*()
        {
            return _pNode->_val;
        }

        Ptr operator->()
        {
            return &_pNode->_val;
        }

        Self& operator++()
        {

            _pNode = _pNode->_pNext;
            return *this;
        }

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

        Self& operator--()
        {
            _pNode = _pNode->_pPre;
            return *this;
        }

        Self operator--(int)
        {
            Self tmp(*this);
            _pNode = _pNode->_pPre;
            return tmp; 
        }

        bool operator!=(const Self& it)
        {
            return _pNode != it._pNode;
        }

        bool operator==(const Self& it)
        {
            return _pNode == it._pNode;
        }
        PNode _pNode;
    };



    //list类

    template<class T>
    class list
    {
        typedef ListNode<T> Node;
        typedef Node* PNode;
    public:
        typedef ListIterator<T, T&, T*> iterator;
        typedef ListIterator<T, const T&, const T&> const_iterator;
    public:
        ///
        // List的构造
        list()
        {
            _pHead = new Node;
            _pHead->_pNext = _pHead;
            _pHead->_pPre = _pHead;
        }
        list(int n, const T& value = T())
        {
            CreateHead();
            for (int i = 0; i < n; i++)
            {
                push_back(value);
            }
        }
        template <class Iterator>
        list(Iterator first, Iterator last)
        {   
            CreateHead();
            while (first != last)
            {
                push_back(*first);
                ++first;
            }
        }
        list(const list<T>& it)
        {
            CreateHead();
            list<T> tmp(it.begin(), it.end());
            std::swap(_pHead, tmp._pHead);
        }
        list<T>& operator=(list<T> it)
        {

            std::swap(_pHead, it._pHead);
            return *this;
        }
        void clear()
        {
            iterator it = begin();
            while (it != end())
            {
                erase(it++);
            }
        }
        ///
        // List Iterator

        iterator begin()
        {
            return iterator(_pHead->_pNext);
        }

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

        const_iterator begin() const
        {
            return const_iterator(_pHead->_pNext);
        }

        const_iterator end() const
        {
            return const_iterator(_pHead);
        }
        /

         List Capacity
        size_t size() const
        {
            size_t i = 0;
            const_iterator it = begin();
            while (it != end())
            {
                i++;
                it++;
            }
            return i;
        }

        bool empty()const
        {
            return _pHead->_pNext == _pHead->_pPre;
        }

        //

         List Access
        T& front()
        {
            return * begin();
        }

        const T& front()const
        {
            return *begin();
        }

        T& back()
        {
            return *(--end());
        }

        const T& back()const
        {
            return *(--end());
        }


        

        // List Modify

        void push_back(const T& val)
        {
           /*PNode newnode = new Node(val);
            PNode tail = _pHead->_pPre;
            _pHead->_pPre = newnode;
            tail->_pNext = newnode;
            newnode->_pNext = _pHead;
            newnode->_pPre = tail;*/
           insert(end(), val);
        }

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

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

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

        // 在pos位置前插入值为val的节点

        iterator insert(iterator pos, const T& val)
        {
            PNode newnode = new Node(val);
            PNode cur = pos._pNode;
            PNode pre = cur->_pPre;

            cur->_pPre = newnode;
            newnode->_pNext = cur;
            pre->_pNext = newnode;
            newnode->_pPre = pre;

            return iterator(newnode);
        }

         删除pos位置的节点，返回该节点的下一个位置

        iterator erase(iterator pos)
        {
            PNode next = pos._pNode->_pNext;
            PNode pre = pos._pNode->_pPre;
            pre->_pNext = next;
            next->_pPre = pre;
            delete pos._pNode;
            return iterator(next);
        }
         
        void clear()
        { 
            iterator it = begin();
            while (it != end())
            {
                erase(it++);
            }
        }

        void swap(list<T>& it)
        {
            PNode tmp = it._pHead;
            it._pHead = _pHead;
            _pHead = tmp;

        }
        void Print()
        {
            for (auto it : *this)
            {
                std::cout << it << ' ';
            }
            std::cout << std::endl;
        }

    private:

        void CreateHead()
        {
            _pHead = new Node();
            _pHead->_pNext = _pHead;
            _pHead->_pPre = _pHead;
        }

        PNode _pHead;

    };

};

**结尾语：**以上就是list的模拟实现。

动名词
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
c++STL容器讲义与演示
01-25
本讲义将深入探讨STL容器，这些容器是STL的核心组成部分，它们在存储和管理数据方面提供了极大的便利。 一、STL容器概述 STL容器是一系列预定义的类模板，用于存储和操作不同类型的元素集合。主要有四大类容器：...
C++ 自定义单向链表 ListNode
qq_43799400的博客
02-15 1334
直接上代码： #include <iostream> #include <assert.h> #include <vector> #include <algorithm> using namespace std; /* * 链表有两种： * 1、带头结点，头结点存放的是链表的长度，从第二个节点开始存放数据。 * 2、不带头结点，没有存放链表长度的节点，从头结点开始就存放数据。 * 我这里定义的链表是第二种。 */ struct ListNode {
【初阶数据结构与算法】第四篇：链表面试题详解
YQ20210216的博客
03-21 1586
⭐️本篇博客我要给大家分享一下算法中的链表例题。希望对大家有所帮助。 ⭐️ 博主码云gitee链接：码云主页 前言 ​ 🌏一、移除链表元素（传送门） 🍤给你一个链表的头节点 head 和一个整数 val ，请你删除链表中所有满足 Node.val == val 的节点，并返回 新的头节点 。 示例 1： 输入：head = [1,2,6,3,4,5,6], val = 6 输出：[1,2,3,4,5] 🔑思路： struct L...
DAY3:链表（一）：链表基础知识+移除链表元素
CFY1226的博客
05-13 2430
/ 单链表的定义 struct ListNode {int val;//节点上储存的元素 ListNode * next;//指向下一个节点的指针 ListNode(int x) : val(x) , next(NULL) {//节点的构造函数 } }//定义指针，指向链表对象（虚拟头节点用法）所以如果不定义构造函数使用默认构造函数的话，在初始化的时候就不能直接给变量赋值！首先，你需要一个指针来找到要删除的节点。这个指针通常是通过遍历链表得到的。
数据结构-链表
temperamentalkj
03-23 2047
链表1、hot100 - 2. 两数相加 1、hot100 - 2. 两数相加 题目：https://leetcode-cn.com/problems/add-two-numbers/ 时间复杂度：O(max(m,n)) 空间复杂度：O(1)。注意返回值不计入空间复杂度 /** * Definition for singly-linked list. * struct ListNode { * int val; * ListNode *next; * ListNode(
Array，List，Struct可能被大家忽略的问题
andy930606的博客
11-29 173
Q1： 首先定义一个结构 public struct MyStruct { public int T; } 定义一个泛型List来存放结构体，然后访问第一个元素去修改T，输出T： List<MyStruct> arrLis =new List<MyStruct>(){new MyStruct()}; arrLis[0].T = 100; Consol...
c++STL学习——各种容器的技术总结和用法代码实例
09-12
学习STL容器不仅仅是理论知识，更重要的是通过实际编码来加深理解。你可以尝试创建这些容器，向其中添加元素，然后进行遍历、插入、删除等操作，体验它们的不同性能和使用方式。 10. 性能分析： 在选择容器时，要...
STL源码剖析——侯捷
05-11
首先，容器是STL的基础，它提供了存储和组织数据的结构，如vector（动态数组）、list（双向链表）、set（红黑树）和map（关联数组）。每种容器都有其特定的性能特性和适用场景，例如，vector适合随机访问，而list...
C++——STL
04-06
C++ STL，全称为Standard Template Library（标准模板库），是C++编程语言中不可或缺的一部分，它为程序员提供了高效且灵活的容器、迭代器、算法和函数对象等工具，极大地提升了代码的可读性和复用性。STL的核心概念...
linux_gdb——sgi_stl——文件锁——程序自动重启
08-16
2. **SGI STL**：SGI STL（Standard Template Library，标准模板库）是C++编程中的一个核心组件，包含了一系列容器（如vector、list、map）、迭代器、算法和函数对象。它提供了一种高效、灵活的方式来处理数据结构和...
力扣LeetCode-链表
weixin_56005963的博客
02-16 516
链表 一、链表节点定义 // 单链表 struct ListNode { int val; // 节点上存储的元素 ListNode *next; // 指向下一个节点的指针 ListNode(int x) : val(x), next(NULL) {} // 节点的构造函数 }; 定义一个节点 ListNode* head = new ListNode(5); 二、设置虚拟头结点 作用：设置虚拟头结点使对头结点的处理普遍化 ListNode* dummyH...
数据结构与算法作业1——数组链表入门
Mike峰
09-21 253
习题1 删除列表的倒数第n个节点 题目链接 方法一 暴力求解 （1）先遍历得到链表的节点个数 （2）删除链表的第L-N+1个节点 时间复杂度：o(n) 空间复杂度：o(1) 方法二
C语言单链表的总结
zdsey的博客
05-04 1681
文章目录初始节点结构：建链：插入：尾插法：头插法：打印链表：删除节点： 初始节点结构： struct ListNode { int val; struct ListNode *next; } 建链： struct ListNode* createlist() { struct ListNode* Hnode = (struct ListNode*)malloc(sizeof(struct ListNode)); Hnode -> next = NULL; return Hnode; }
详解STL里的List底层代码
Blog
05-26 662
ListNode.h typedef int Rank; #define ListNodePosi(T) ListNode<T>* //列表节点位置 template <typename T>struct ListNode//列表节点模板类(以双向链表形式展现) { //成员 T data; ListNodePosi(T) pred;ListNodePosi(T)...
【C++系列】STL中的list用法详解及模拟实现
Li-eng的博客
11-16 1125
list详解及模拟底层实现 一，list的介绍与使用 list的文档介绍（官网） list是可以在常数范围内在任意位置进行插入和删除的序列式容器，并且该容器可以前后双向迭代。 list的底层是双向链表结构，双向链表中每个元素存储在互不相关的独立节点中，在节点中通过指针指向 其前一个元素和后一个元素。 list与forward_list非常相似：最主要的不同在于forward_list是单链表，只能朝前迭代，已让其更简单高效。 与其他的序列式容器相比(array，vector，deque)，list通常在
【算法学习笔记- ListNode struct创建、遍历】
zhjali123的专栏
10-02 1953
Context 我使用的struct创建的，GitHub,源码地址 Struct遇到的坑 struct ListNode { int m_nValue; ListNode* m_next; }; ListNode test1; cout << "\ntest: " << &test1; ...
struct ListNode { * int val； * ListNode *next； * ListNode(int x) : val(x), next(NULL)
qq_30334533的博客
07-10 8458
构造函数的初始化
C++ 基础STL-list容器
好好学习，天天向上
05-12 322
STL-list容器
STL常用容器—list容器（链表）
最新发布
weixin_46216674的博客
02-03 1319
整理总结C++ STL中list常用容器，主要实现对链表的基本操作，包括增删改查以及翻转、排序等常见操作
C++ stl容器特性
09-01
- *1* [C++——STL容器](https://blog.csdn.net/JAN6055/article/details/122758690)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

动名词

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

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

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

打赏作者

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

抵扣说明：

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

余额充值