C++_list的实现

最新推荐文章于 2024-07-22 12:11:04 发布
最新推荐文章于 2024-07-22 12:11:04 发布
阅读量122 收藏
点赞数
文章标签： c++ list 链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_66232462/article/details/129713634
版权
该文详细介绍了如何使用C++模板类实现一个带有哨兵节点的双向链表，包括节点结构、构造函数、拷贝构造、赋值构造、迭代器的定义及操作符重载，以及插入和删除等操作。文章强调了迭代器在链表操作中的重要性，并提供了测试示例。
摘要由CSDN通过智能技术生成

类的成员变量

类的私有成员变量只要一个哨兵位节点_head

template<class T>
    class list
    {
        typedef list_node<T> node;//方便写代码
    public:
		}

为了方便写代码，我们把list_node重命名为node

template<class T>
    struct list_node//struct 不打算对成员进行限制
    {
        //node的初始化
        T _data;
        list_node<T>* _next;
        list_node<T>* _prev;

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

使用struct定义list_node是为了不对成员进行限制，外部可以修改它。

把node封装成struct后，当对象实例化时，会调用list_node这个结构体中的构造函数，并将node型对象初始化，这样初始化会首先创建一个哨兵位节点：_head。

基本函数

swap

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

链表的交换很方便，直接交换头节点即可。

封装初始化：

void empty_init()
        {
            _head=new node;
            _head->_next=_head;
            _head->_prev=_head;
        }

把构造初始化封装起来，让多个构造函数可以使用，减少代码量。

构造初始化、拷贝构造

无参构造：

list()
        {
						empty_init();
         // _head=new node;
         // _head->_next=_head;
         // _head->_prev=_head;
        }

_head的初始化直接调用list_node)。

其他拷贝构造都需要这三行，封装起来后可以节省代码量。

迭代器遍历拷贝构造：

template <class Iterator>
list(Iterator first, Iterator last)
        {
            empty_init();//初始化
            while (first != last)
            {
                push_back(*first);//依次插入迭代器中的值
                ++first;
            }
        }

迭代器传入后，依次遍历迭代器中的值并尾插到this中，即可完成迭代器拷贝构造。

lt2(lt1)拷贝构造：

list(const list<T>& lt)//拷贝构造
        {
            empty_init();
            list<T> tmp(lt.begin(), lt.end());//用迭代器拷贝构造后再交换值
            swap(tmp);
        }

复用拷贝构造后this和tmp交换头节点指针即可。

赋值重载拷贝构造：

list<T>& operator=(list<T> lt)//赋值拷贝构造
        {
            swap(lt);
            return *this;
        }

传入lt然后this和它交换，再返回*this即可。

注意：传入的list类型是形参，如果传入引用，那lt就会被交换掉，不是拷贝构造了，是交换！

迭代器的实现

首先在类中定义一个迭代器中需要什么类型的值并重命名，如下代码所示

template<class T>
    class list
    {
        typedef list_node<T> node;//方便写代码
    public:
        typedef __list_iterator<T,T&,T*> iterator;//迭代器
        typedef __list_iterator<T,const T&,const T*> const_iterator;//const迭代器
		}

对象实例化时，把类型传入模版中，例如int型，那么传入迭代器中的三种类型分别为：int,int&,int*

const迭代器亦是如此：int , const int& , constT*

在类外定义迭代器：

template<class T,class Ref,class Ptr>
    struct __list_iterator
    {
        typedef list_node<T> node;//局部重命名
        typedef __list_iterator<T,Ref,Ptr> self;
        node* _node;

        __list_iterator(node* n)//n传的是一个去掉哨兵位head的头节点指针
        :_node(n)//_node被赋值的是头节点指针，此时_node就是一个没有哨兵位节点的链表！
        {}
    };

当迭代器被构造时，传入的node* n是一个指针，且应该是一个不带哨兵位节点的指针，因为迭代器中的值应当都有效，哨兵位中数据无效。

例如：迭代器中传入的是_head→next；那么迭代器指向的就是第一个节点。

Tip：迭代器不释放节点，释放是list的事情，迭代器只是使用节点为用户读写。

迭代器基本函数：

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

使用匿名对象返回值编译器更容易优化，begin()迭代器指向的是第一个有效节点，即_head->next(哨兵位无效)。

把哨兵位节点_head当作尾节点，当begin()迭代器遍历到_head(即end()迭代器)时，可以判断此链表已经结束迭代。

Tip：哨兵位相当于string中的npos，用来判断双向循环链表的结束。

迭代器的操作符重载：

				Ref operator*()//解引用，把节点中的值放出来
        {
            return _node->_data;//值是模版类型
        }

        Ptr operator->()//返回的是T类型指针，T*
        {
            return &_node->_data;
        }
        self& operator++()
        {
            _node=_node->_next;//迭代器往后走
            return *this;//直接返回this，此时this->node的头节点已经变更
        }
        self operator++(int)//后置++括号中写int
        {
            self tmp(*this);//保存之前的节点
            _node=_node->_next;//迭代器往后走
            return tmp;//后置++特性就是先用后加
        }
        self& operator--()
        {
            _node=_node->_prev;//迭代器往前走
            return *this;//直接返回this，此时this->node的头节点已经变更
        }
        self operator--(int)//后置--括号中写int
        {
            self tmp(*this);//保存之前的节点
            _node=_node->_prev;//迭代器往前走
            return tmp;//后置--特性就是先用后减
        }

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

如上代码注释，除了后置++和后置- -其他没什么好说的，都是基本的重载。

后置++和后置- -都是先用再加，所以返回的值应该是原本的值，先用tmp把原本的节点存起来，迭代器再往后走，返回tmp。

->指向重载：

Ptr operator->()//返回的是T类型指针，T*
        {
            return &_node->_data;
        }

		struct AA
    {
        int _a1;
        int _a2;

        AA(int a1 = 0, int a2 = 0)
                :_a1(a1)
                , _a2(a2)
        {}
    };

    void test2()
    {
        list<AA> lt;
        lt.push_back(AA(1, 1));
        lt.push_back(AA(2, 2));
        lt.push_back(AA(3, 3));

        // AA* ptr
        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->()->_a1 << endl;
            ++it;
        }
        cout << endl;
    }

如上所示，当一个结构体中有两个值，我们需要访问时，需要用指向->来访问地址中的数据，所以需要重载->，为了可读性，可以省略一个->来指向访问。

反向迭代器

namespace lty
{
    template<class Iterator, class Ref, class Ptr>
    struct ReverseIterator
    {
        typedef ReverseIterator<Iterator, Ref, Ptr> Self;
        Iterator _cur;

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

        Ref operator*()
        {
            Iterator tmp = _cur;
            --tmp;
            return *tmp;
        }

        Self& operator++()//反向迭代器的++就是--，--就是++
        {
            --_cur;
            return *this;
        }

        Self& operator--()
        {
            ++_cur;
            return *this;
        }

        bool operator!=(const Self& s)
        {
            return _cur != s._cur;
        }
    };
}

复用正向迭代器，当迭代器进行自增/自减操作时，调用的是正向迭代器的自减/自增，和正向迭代器是反着来的。

解引用时，因为反向迭代器是从end()开始的rbegin()，当需要解引用时，应当取前面那个值：

在这里插入图片描述

插入和删除

insert插入：

void insert(iterator pos, const T& x)
        {
            //pos迭代器里面的_node是指针，例如begin()传入pos，那么_node被初始化为_head->next，pos._node=_head->next。
            node* cur = pos._node;  //定义cur头指向pos位置的节点
            node* prev = cur->_prev;//prev指向pos前一个节点

            node* new_node = new node(x);
           
            prev->_next = new_node;//链上新节点
            new_node->_prev = prev;//新节点前一个节点为之前的尾节点
            new_node->_next = cur;//尾后链头
            cur->_prev = new_node;//头前链尾
        }

在pos位置插入即是头。

参数pos迭代器里面存的_node是指针，pos也是一个指针，所以节点的引用是pos._node

Tip：insert操作时迭代器不会失效，依旧指向的是原来的节点

双向链表的插入如图所示：

在这里插入图片描述

erase删除：

iterator 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;//迭代器失效
            return iterator(next);//防止外部迭代器失效
        }

首先断言链表是否为空，为空时无法删除，且哨兵位节点不能被删除。

迭代器失效：当重新链完节点后，删除pos位置的节点，此时迭代器失效，被delete掉了。

erase函数可以返回一个迭代器防止外部迭代器失效：即返回pos位置的下一个节点。

头插删尾插删：

				void push_back(const T& x)
        {
            insert(end(),x);//尾插复用insert，在迭代器end处插入x
        }

        void push_front(const T& x)
        {
            insert(begin(),x);//头插在begin处插入x
        }

        void pop_front()
        {
            erase(begin());//复用头删
        }

        void pop_back()
        {
            erase(--end());//复用erase，尾删，不能删end位置的哨兵位节点。
        }

完成insert和erase后，链表的头插删和尾插删复用它们即可。

头文件源码：

#include <assert.h>
namespace lty
{
    template<class T>
    struct list_node//struct 不打算对成员进行限制
    {
        //node的初始化
        T _data;
        list_node<T>* _next;
        list_node<T>* _prev;

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

    template<class T,class Ref,class Ptr>
    struct __list_iterator//迭代器不释放节点，释放是链表list的事情，迭代器只是使用节点为用户读写
    {
        typedef list_node<T> node;//局部重命名
        typedef __list_iterator<T,Ref,Ptr> self;
        node* _node;

        __list_iterator(node* n)//n传的是一个去掉哨兵位head的头节点指针
        :_node(n)//_node被赋值的是头节点指针，此时_node就是一个没有哨兵位节点的链表！
        {}

        Ref operator*()//解引用，把节点中的值放出来
        {
            return _node->_data;//值是模版类型
        }

        Ptr operator->()//返回的是T类型指针，T*
        {
            return &_node->_data;
        }
        self& operator++()
        {
            _node=_node->_next;//迭代器往后走
            return *this;//直接返回this，此时this->node的头节点已经变更
        }
        self operator++(int)//后置++括号中写int
        {
            self tmp(*this);//保存之前的节点
            _node=_node->_next;//迭代器往后走
            return tmp;//后置++特性就是先用后加
        }
        self& operator--()
        {
            _node=_node->_prev;//迭代器往前走
            return *this;//直接返回this，此时this->node的头节点已经变更
        }
        self operator--(int)//后置--括号中写int
        {
            self tmp(*this);//保存之前的节点
            _node=_node->_prev;//迭代器往前走
            return tmp;//后置--特性就是先用后减
        }


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


    };


    template<class T>
    class list
    {
        typedef list_node<T> node;//方便写代码
    public:
        typedef __list_iterator<T,T&,T*> iterator;//迭代器
        typedef __list_iterator<T,const T&,const T*> const_iterator;//const迭代器

        iterator begin()
        {
            return iterator(_head->_next);//匿名对象编译器更容易优化，传入_head->next后迭代器中的链表没有哨兵位节点了
        }
        iterator end()
        {
            return iterator(_head);//把_head当作尾节点，当begin迭代器++到_head时，可以判断此链表已经结束迭代
        }
        const_iterator begin() const
        {
            return const_iterator(_head->_next);
        }
        const_iterator end() const
        {
            return const_iterator(_head);
        }

        void empty_init()//构造初始化 封装起来 让多个构造可以使用
        {
            _head=new node;
            _head->_next=_head;
            _head->_prev=_head;
        }

        void swap(list<T>& tmp)//交换头节点即可
        {
            std::swap(_head, tmp._head);
        }

        list()
        {
//            empty_init();
            _head=new node;
            _head->_next=_head;
            _head->_prev=_head;
        }

        template <class Iterator>
        list(Iterator first, Iterator last)//用迭代器拷贝构造
        {
            empty_init();//初始化
            while (first != last)
            {
                push_back(*first);//依次插入迭代器中的值
                ++first;
            }
        }

        //lt2(lt1);
        list(const list<T>& lt)//拷贝构造
        {
            empty_init();
            list<T> tmp(lt.begin(), lt.end());//用迭代器拷贝构造后再交换值
            swap(tmp);
        }

        list<T>& operator=(list<T> lt)//赋值拷贝构造
        {
            swap(lt);
            return *this;
        }
        void push_back(const T& x)
        {
//            node* tail=_head->_prev;
//            node* new_node=new node(x);
//
//            tail->_next=new_node;//链上新节点
//            new_node->_prev=tail;//新节点前一个节点为之前的尾节点
//            //双向循环链表
//            new_node->_next=_head;//尾后链头
//            _head->_prev=new_node;//头前链尾
            insert(end(),x);//尾插复用insert，在迭代器end处插入x
        }

        void push_front(const T& x)
        {
            insert(begin(),x);//头插在begin处插入x
        }

        void pop_front()
        {
            erase(begin());//复用头删
        }

        void pop_back()
        {
            erase(--end());//复用erase，尾删，不能删end位置的哨兵位节点。
        }

        //在pos位置插入=头插
        void insert(iterator pos, const T& x)//迭代器不会失效
        {
            //pos迭代器里面的_node是指针，例如begin()传入pos，那么_node被初始化为_head->next，pos._node=_head->next。
            node* cur = pos._node;  //定义cur头指向pos位置的节点
            node* prev = cur->_prev;//prev指向pos前一个节点

            node* new_node = new node(x);
            //画图理解
            prev->_next = new_node;//链上新节点
            new_node->_prev = prev;//新节点前一个节点为之前的尾节点
            new_node->_next = cur;//尾后链头
            cur->_prev = new_node;//头前链尾
        }
        //画图理解
        iterator erase(iterator pos)//此处的pos迭代器会失效，被delete掉了
        {
            assert(pos != end());//不能删除哨兵位节点，需断言

            node* prev = pos._node->_prev;
            node* next = pos._node->_next;

            prev->_next = next;
            next->_prev = prev;
            delete pos._node;//迭代器失效
            return iterator(next);//防止外部迭代器失效
        }

        ~list()
        {
            clear();//除了哨兵位节点没删其余都删了
            delete _head;//删除哨兵位节点并置空
            _head= nullptr;
        }

        void clear()
        {
            iterator it=begin();
            while(it!=end())
            {
                //it= erase(it);//删除一个后，erase返回下一个节点给it，防止it失效
                erase(it++);//后置++重载返回的是tmp，迭代器it再往后移动，it也不会失效
            }
        }


    private:
        node* _head;//哨兵位节点

    };


    void Print(const list<int>& lt)
    {
        list<int>::const_iterator it = lt.begin();
        while (it != lt.end())
        {
            //(*it) *= 2;
            cout << *it << " ";
            ++it;
        }
        cout << endl;
//        for(auto e:lt)
//        {
//            cout << e << " ";
//        }
//        cout << endl;
    }
    //测试
    void test1()
    {
        list<int> lt;
        lt.push_back(1);
        lt.push_back(2);
        lt.push_back(3);
        lt.push_back(4);
        list<int>::iterator it=lt.begin();
        Print(lt);
        cout << endl;

    }

    struct AA
    {
        int _a1;
        int _a2;

        AA(int a1 = 0, int a2 = 0)
                :_a1(a1)
                , _a2(a2)
        {}
    };

    void test2()
    {
        list<AA> lt;
        lt.push_back(AA(1, 1));
        lt.push_back(AA(2, 2));
        lt.push_back(AA(3, 3));

        // AA* ptr
        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->()->_a1 << endl;
            ++it;
        }
        cout << endl;
    }

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

        auto pos = lt.begin();
        ++pos;
        lt.insert(pos, 20);
        Print(lt);

        lt.push_back(100);
        lt.push_front(1000);
        Print(lt);

        lt.pop_back();
        lt.pop_front();
        Print(lt);
    }
}
吃芒果吗你
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
模拟实现list超详解（C++）
m0_67430750的博客
04-25 3199
简易版list模拟实现超详解
list_list_STL_C++_
09-29
`list`是C++ STL中的一个模板类，它实现了一个双向链表。这意味着每个元素都有指向前一个和后一个元素的指针，允许双向遍历。这种数据结构的优点在于插入和删除操作通常比数组或向量更快，因为它们不需要移动元素。`...
C++list容器list构造函数
qq_36711295的博客
09-11 559
C++list容器list构造函数 #include <iostream> #include <list> using namespace std; void printList(const list<int>& l) { for (list<int>::const_iterator it = l.begin(); it != l.end(); ++it) { cout << *it << " "; } cout &
【爱上C++】list用法详解、模拟实现
最新发布
2301_76677973的博客
07-22 4464
文档在这里→官方文档←list是可以在常数范围内（ 时间复杂度为O(1) ）在任意位置进行插入和删除的序列式容器，并且该容器可以前后双向迭代(双向迭代器)。list的底层是双向链表结构，双向链表中每个元素存储在互不相关的独立节点中，在节点中通过指针指向其前一个元素和后一个元素。list与forward_list非常相似：最主要的不同在于forward_list是单链表，只能朝前迭代，已让其更简单高效。
C++ - list简单实现
xd6905的博客
03-16 2021
目录 一、整体框架 二、节点类 三、迭代器类 四、list类 1.构造与析构 1.1普通构造 1.2迭代器区间构造 1.3拷贝构造与赋值 1.4析构 2.迭代器指针、头尾数据 3.容量 4.插入和删除 一、整体框架 总共可分为节点类，迭代器类和list类三大块。 // List的节点类 template<class T> struct ListNode { ListNode(c...
【 C++ 】list的模拟实现
bit_zyx的博客
08-21 616
目录 1、list三个基本模板类 2、结点类接口实现 基本框架 构造函数 3、迭代器类接口实现 3.1、正向迭代器 基本框架 默认成员函数 构造函数 * 运算符重载 ->运算符重载 ++运算符重载 --运算符重载 ...
C++手动实现list
weixin_50941083的博客
01-08 1463
C++实现list
track_轨迹显示_list_C++_sheetcu4_track.csv_
09-29
标题中的"track_轨迹显示_list_C++_sheetcu4_track.csv_"揭示了这个项目的核心内容。这是一款使用C++编程语言实现的轨迹显示系统，它能够记录运动轨迹，并将这些数据存储为CSV（Comma Separated Values）格式的文件...
LIST.zip_C/C++__C/C++_
08-09
标题 "LIST.zip_C/C++__C/C++_" 涉及到的是一个 C/C++ 编程任务，其中的核心知识点是文件操作和链表的管理。这个任务要求开发者编写程序，能够从两个无序的数据文件中读取内容，然后利用链表数据结构将这些数据按...
Ex_8_List.rar_c++ 图标list_缩略图
09-22
标题中的“Ex_8_List.rar_c++ 图标list_缩略图”暗示这是一个使用C++编程语言实现的项目，重点在于列表视图(List View)的展示，其中包含了图标显示和缩略图的功能。这个程序可能是一个Windows桌面应用程序，因为...
gen_list_广义表_genlist工具_C++_数据结构_
09-29
4. **STL容器**：C++标准模板库（STL）中的容器，如`std::vector`或`std::list`，可以通过适配器或自定义迭代器来实现广义表的功能。 genlist工具可能结合了以上一种或多种方法，提供了一种方便的方式来操作广义表...
C++中list的简单实现
winterright的博客
05-20 648
一步一步走，缺什么补什么，不缺的放后边实现，这样子可以减少分支，以上就是这里list的实现了，简单实现一下，这里重要的是理解迭代器，迭代器不一定是指针，这里变成管理指针的类了
C++中的list类【详细分析及模拟实现】
kevvviinn的博客
03-26 2998
本文介绍C++STL中的第三个容器——list类，详细介绍并使用库中为我们提供的接口，并配以多道测试实例帮助运用，然后我们深度剖析了如何模拟实现list类，包括设计思路以及方法的实现；最后比较了vector和list两种容器的优劣
C++入门篇(13)之list的实现
m0_51723227的博客
11-24 4189
文章目录前言list的结构搭建两种构造函数① 默认构建函数② 迭代器区间构建函数拷贝构造函数赋值重载数据的头尾删插① 尾插push_back()② 尾删pop_back()③ 头插push_front()④ 头删pop_front()迭代器的实现迭代器接口clear()清理析构函数erase和insert的实现and简化头尾数据删除最终list代码 前言 上一节我们简单叙述了一下list的概念,知道其底层是一个带头结点的双向循环链表,并且介绍了其使用方法,**但是!**知其然未必知其所以然,我们不但应该知其
C++编程入门之十三（list容器）
qq_42832272的博客
05-16 243
list容器 1.1list基本概念 1.2list构造函数 #include"pch.h" #include<iostream> #include<string> #include<opencv2/opencv.hpp> #include<vector> #include<algorithm> // 标准算法头文件 ...
【C++】list模拟实现
chuxinchangcun的博客
01-10 6256
由源码可以得知,list的底层是带头双向循环链表—list实际上是一个带头双向循环链表,要实现list,则首先需要实现一个结点类,而一个结点需要存储的信息为:数据、前驱指针、后继指针而对于该结点类的成员函数来说,我们只需实现一个构造函数即可,因为该结点类只需要根据数据来构造一个结点即可,而结点的释放则由list的析构函数来完成, 构造函数 构造函数直接根据所给数据构造一个结点即可,构造出来的结点的数据域存储的就是所给数据,而前驱指针和后继指针均初始化为空指针即可 若构造结点时未传入数据,则默认以list
【C++数据结构】双向链表list实现
我的博客
01-13 285
本次实现也是练习而已，如有问题，欢迎指出！ 编译环境：GCC 7.3、vs 2005 与标准库list的差异： 1. 没有splice 2. 没有uniqe 3. 没有merge 4. 没有sort 好了，直接上代码： #ifndef __LIST_H__ #define __LIST_H__ #if __cplusplus >= 201103L #include &lt...
C++STL list容器 数据存取 反转和排序 自定义数据类型排序案例 list成员函数sort高级排序
UUUUU22的博客
03-13 1284
C++STL list容器 数据存取 反转和排序 自定义数据类型排序案例 list成员函数sort高级排序
C++模拟list实现与迭代器详解
C++ 模拟实现list（迭代器）是一种数据结构，用于管理动态大小的双向链表。在C++中，`list`通常由`std::list`库提供，但为了教学或理解底层工作原理，我们可以自定义一个简单的模拟实现。本文档主要关注两个关键部分...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值