20. C++使用HashTable同时出封装unordered_map和unordered_set

最新推荐文章于 2025-08-15 18:53:39 发布
最新推荐文章于 2025-08-15 18:53:39 发布
阅读量435 收藏 8
点赞数 3
CC 4.0 BY-SA版权
分类专栏： C++ 文章标签： c++ 哈希算法 散列表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2201_76004325/article/details/147758586

文章目录

模板参数控制

unordered_set是K模型的容器，而unordered_map是KV模型的容器

  • 为了与原哈希表的模板参数进行区分，这里将哈希表的第二个模板参数的名字改为T。
template<class K, class T>
class HashTable
  • 如果使用的是unordered_set容器，那么传入哈希表的模板参数就是key和key。
template<class K>
class unordered_set
{
public:
    //...
private:
    hash_bucket::HashTable<K, K> _ht; //传入底层哈希表的是K和K
};
  • 但如果使用的是unordered_map容器，那么传入哈希表的模板参数就是key以及key和value构成的键值对。
template<class K, class V>
class unordered_map
{
public:
    //...
private:
    HashTable<K, pair<K, V>> _ht; //传入底层哈希表的是K以及K和V构成的键值对
};

而哈希结点的模板参数也应该由原来的K、V变为T：

  • 上层容器是unordered_set时，传入的T是键值，哈希结点中存储的就是键值。
  • 上层容器是unordered_map时，传入的T是键值对，哈希结点中存储的就是键值对。

更改模板参数后，哈希结点的定义如下：

//哈希结点的定义
template<class T>
struct HashData
{
    HashData<T>* _next;
    T _data;

    // 构造
    HashData(const T& data)
        :_data(data)
        , _next(nullptr)
    {}
};

哈希表正向迭代器的实现

哈希表的正向迭代器实际上就是对哈希结点指针进行了封装，但是由于在实现++运算符重载时，可能需要在哈希表中去寻找下一个非空哈希桶，因此每一个正向迭代器中都应该存储哈希表的地址。

template<class K, class T, class KeyOfT, class HashFunc = Hash<K>>
struct __HTIterator
{
    typedef HashNode<T> Node; //哈希结点的类型
    typedef HashTable<K, T, KeyOfT, HashFunc> HT; //哈希表的类型
    typedef __HTIterator<K, T, KeyOfT, HashFunc> Self; //正向迭代器的类型

    Node* _node; //结点指针
    HT* _pht; //哈希表的地址
    // 构造
    __HTIterator(Node* node,HT* ht)
        :_node(node)
        ,_pht(ht)
    {}
};
接引用和->
T& operator*()
{
    //返回哈希结点中数据的引用
    return _node->_data;
}
T* operator->()
{
    //返回哈希结点中数据的地址
    return &_node->_data; 
}
判断节点是否同一个
bool operator!=(const Self& s) const
{
    return _node != s._node;
} 

bool operator==(const Self& s) const
{
    return _node == s._node;
}
++运算符重载函数
  • 若当前结点不是当前哈希桶中的最后一个结点，则++后走到当前哈希桶的下一个结点。
  • 若当前结点是当前哈希桶的最后一个结点，则++后走到下一个非空哈希桶的第一个结点。
Self& operator++()
{
    if (_node->_next)
    {
        // 当前桶还有节点，走到下一个节点
        _node = _node->_next;
    }
    else
    {
        // 当前桶已经走完了，找下一个桶开始
        KeyOfT kot;
        Hash hs;
        size_t hashi = hs(kot(_node->_data)) % _ht->_tables.size();
        ++hashi;
        while (hashi < _ht->_tables.size())
        {
            if (_ht->_tables[hashi]) // 如果桶存在
            {
                // 找到了
                _node = _ht->_tables[hashi];
                break;
            }
            else
            {
                // 继续往后找
                ++hashi;
            }
        }

        // 走完了
        if (hashi == _ht->_tables.size())
            _node = nullptr;
    }
    return *this;
}

HashTable.h

#pragma once
#include <vector>
#include <iostream>

static const int __stl_num_primes = 28;
static const unsigned long __stl_prime_list[__stl_num_primes] =
{
    53,         97,         193,       389,       769,
    1543,       3079,       6151,      12289,     24593,
    49157,      98317,      196613,    393241,    786433,
    1572869,    3145739,    6291469,   12582917,  25165843,
    50331653,   100663319,  201326611, 402653189, 805306457,
    1610612741, 3221225473, 4294967291
};

inline unsigned long __stl_next_prime(unsigned long n)
{
    const unsigned long* first = __stl_prime_list;
    const unsigned long* last = __stl_prime_list + __stl_num_primes;
    const unsigned long* pos = std::lower_bound(first, last, n);
    return pos == last ? *(last - 1) : *pos;
}


template<class K>
struct HashFunc
{
    size_t operator()(const K& key)
    {
        return (size_t)key;
    }
};

// 特化
template<>
struct HashFunc<std::string>
{
    size_t operator()(const std::string& key)
    {
        size_t hashi = 0;
        for (auto& e : key)
        {
            hashi *= 131;
            hashi += e;
        }
        return hashi;
    }
};

namespace hash_bucket
{
    template<class T>
    struct HashNode
    {
        T _data;
        HashNode<T>* _next;

        // 构造
        HashNode(const T& data)
            :_data(data)
            ,_next(nullptr)
        {}
    };

    // 需要前置声明一下HashTable
    template<class K, class T, class KeyOfT, class Hash>
    class HashTable;

    template<class K, class T, class Ref, class Ptr, class KeyOfT, class Hash = HashFunc<T>>
    struct __HTIterator
    {

        typedef HashNode<T> Node; //哈希结点的类型
        typedef HashTable<K, T, KeyOfT, Hash> HT; // 哈希表的类型
        typedef __HTIterator<K, T, Ref, Ptr, KeyOfT, Hash> Self; //正向迭代器的类型

        Node* _node; //结点指针
        const HT* _ht; //哈希表的地址 // 需要是const

        // 构造
        __HTIterator(Node* node, const HT* ht) // 注意参数
            :_node(node)
            ,_ht(ht)
        {}

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

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

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

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

        Self& operator++()
        {
            if (_node->_next)
            {
                // 当前桶还有节点，走到下一个节点
                _node = _node->_next;
            }
            else
            {
                // 当前桶已经走完了，找下一个桶开始
                KeyOfT kot;
                Hash hs;
                size_t hashi = hs(kot(_node->_data)) % _ht->_tables.size();
                ++hashi;
                while (hashi < _ht->_tables.size())
                {
                    if (_ht->_tables[hashi]) // 如果桶存在
                    {
                        // 找到了
                        _node = _ht->_tables[hashi];
                        break;
                    }
                    else
                    {
                        // 继续往后找
                        ++hashi;
                    }
                }

                // 走完了
                if (hashi == _ht->_tables.size())
                    _node = nullptr;
            }
            return *this;
        }
    };


    // 仿函数不能在这里写缺省参数，必须要在上一层加
    template<class K, class T, class KeyOfT, class Hash>
    class HashTable
    {
        KeyOfT kot; // 用于取值
        Hash hs;    // 用于计算
        typedef HashNode<T> Node;
        ////////////////////////
        // 须要进行友元声明__HTIterator中的_tables才能访问，并且声明不能有缺省参数
        template<class K, class T, class Ref, class Ptr, class KeyOfT, class Hash>
        friend struct __HTIterator;
        ///////////////////////////
    public:
        typedef __HTIterator<K, T, T&, T*, KeyOfT, Hash> Iterator;
        typedef __HTIterator<K, T, const T&, const T*, KeyOfT, Hash> ConstIterator;
        ////////////////////////////////////////////////////
        // 迭代器
        Iterator Begin()
        {
            // 找第一个不为空的桶里面的第一个节点
            for (size_t i = 0; i < _tables.size(); i++)
            {
                if (_tables[i])
                    return Iterator(_tables[i], this);
            }
            return End();
        }

        Iterator End()
        {
            return Iterator(nullptr, this);
        } 

        ConstIterator Begin() const
        {
            // 找第一个不为空的桶里面的第一个节点
            for (size_t i = 0; i < _tables.size(); i++)
            {
                if (_tables[i])
                    return ConstIterator(_tables[i], this);
            }
            return End();
        }

        ConstIterator End() const 
        {
            return ConstIterator(nullptr, this);
        }

        ////////////////////////////////////////////////////
        HashTable(size_t size = __stl_next_prime(0))
            : _tables(size, nullptr)
            , _n(0)
        {}

        ~HashTable()
        {
            for (size_t i = 0; i < _tables.size(); i++)
            {
                Node* cur = _tables[i];
                while (cur)
                {
                    Node* next = cur->_next;
                    delete cur;
                    cur = next;
                }
                _tables[i] = nullptr;
            }
        }

        std::pair<Iterator, bool>Insert(const T& data)
        {
            // 1、查看哈希表中是否存在该键值的键值对
            Iterator it = Find(kot(data));
            if (it != End())
                return { it , false };

            // 2、判断是否需要调整哈希表的大小
            if (_n == _tables.size())
            {
                // a. 建立新表
                std::vector<Node*> newTables(__stl_next_prime(_tables.size() + 1));

                // b、将原哈希表当中的结点插入到新哈希表
                for (size_t i = 0; i < _tables.size(); i++)
                {
                    Node* cur = _tables[i];
                    while (cur)
                    {
                        // 旧表的节点挪动下来插入到映射的新表位置
                        Node* next = cur->_next;   //记录cur的下一个结点
                        size_t hashi = hs(kot(cur->_data)) % newTables.size(); // 通过哈希函数计算出对应的哈希桶编号index

                        cur->_next = newTables[hashi]; // 节点直接拿下来放到新桶中
                        newTables[hashi] = cur; // 将该结点头插到新哈希表中编号为index的哈希桶中
                        cur = next; // 取原哈希表中该桶的下一个结点
                    }
                    _tables[i] = nullptr;  // 该桶取完后将该桶置空
                }
                _tables.swap(newTables);
            } // 扩容end...

            size_t hashi = hs(kot(data)) % _tables.size();
            Node* newnode = new Node(data);
            // 进行头插
            newnode->_next = _tables[hashi];
            _tables[hashi] = newnode;

            ++_n;
            return { {newnode, this}, true };
        }


        Iterator Find(const K& key)
        {
            if (_tables.size() == 0) // 哈希表大小为0，查找失败
                return End();
            // 通过哈希函数计算出对应的哈希桶编号
            size_t hashi = hs(key) % _tables.size();
            Node* cur = _tables[hashi];
            // 遍历哈希桶
            while (cur)
            {
                if (kot(cur->_data) == key)
                    return Iterator(cur, nullptr);
                cur = cur->_next;
            }
            return End();
        }

        bool Erase(const K& key)
        {
            //1、通过哈希函数计算出对应的哈希桶编号index（除数不能是capacity）
            size_t hashi = hs(kot(key)) % _tables.size();

            //2、在编号为index的哈希桶中寻找待删除结点
            Node* cur = _tables[hashi];
            Node* prev = nullptr;
            while (cur)
            {
                //3、若找到了待删除结点，则删除该结点
                if (kot(cur->_data) == key)
                {
                    //待删除结点是哈希桶中的第一个结点
                    if (prev == nullptr)
                        _tables[hashi] = cur->_next;// 将第一个结点从该哈希桶中移除
                    else// 待删除结点不是哈希桶的第一个结点
                        prev->_next = cur->_next; // 前一个节点的next指向cur的next
                    delete cur;
                    --_n; // 4、删除结点后，将哈希表中的有效元素个数减一
                    return true;
                }
                // 继续往后找
                prev = cur;
                cur = cur->_next;
            }
            return false;
        }

    private:
        std::vector<Node*> _tables;
        size_t _n;
    };
}

MyUnorderedSet.h

#pragma once

#include "HashTable.h"

namespace lsl
{
	template<class K, class Hash = HashFunc<K>>
	class unordered_set
	{
		struct SetKeyOfT
		{
			const K& operator()(const K& key)
			{
				return key;
			}
		};
	public:
		// 用第一个也可以
		//typedef typename hash_bucket::HashTable<K, const K, SetKeyOfT, Hash>::ConstIterator iterator;

		typedef typename hash_bucket::HashTable<K, const K, SetKeyOfT, Hash>::Iterator iterator;
		typedef typename hash_bucket::HashTable<K, const K, SetKeyOfT, Hash>::ConstIterator const_iterator;

		// 使用这个也可以
		/*
		using iterator = typename hash_bucket::HashTable<K, const K, SetKeyOfT, Hash>::Iterator;
		using const_iterator = typename hash_bucket::HashTable<K, const K, SetKeyOfT, Hash>::ConstIterator;
		*/

		iterator begin()
		{
			return _ht.Begin();
		}

		iterator end()
		{
			return _ht.End();
		} 

		const_iterator begin() const
		{
			return _ht.Begin();
		}

		const_iterator end() const
		{
			return _ht.End();
		}

		std::pair<iterator, bool> insert(const K& key)
		{
			return _ht.Insert(key);
		}

	private:
		hash_bucket::HashTable<K, const K, SetKeyOfT, Hash> _ht;
	};

    /////////////////测试/////////////
	// const迭代器
	void print(const unordered_set<int>& s)
	{
		unordered_set<int>::const_iterator it = s.begin();
		while (it != s.end())
		{
			//*it = 1;
			std::cout << *it << " ";
			++it;
		}
		std::cout << std::endl;
	}

	void unordered_set_Test()
	{
		unordered_set<int> s;
		s.insert(1);
		s.insert(5);
		s.insert(10);
		s.insert(508);
		s.insert(333);
		s.insert(82);

		for (auto& e : s)
		{
			std::cout << e << " ";
		}
		std::cout << std::endl;

		print(s);

		// set不可以修改
		unordered_set<int>::iterator it = s.begin();
		while (it != s.end())
		{
			//*it = 1;
			std::cout << *it << " ";
			++it;
		}
		std::cout << std::endl;
	}
}

MyUnorderedMap.h

#pragma once

#include "HashTable.h"

namespace lsl
{
	template<class K, class V, class Hash = HashFunc<K>>
	class unordered_map
	{
		struct MapKeyOfT
		{
			const K& operator()(const std::pair<K, V>& kv)
			{
				return kv.first;
			}
		};
	public:
		typedef typename hash_bucket::HashTable<K, std::pair<const K, V>, MapKeyOfT, Hash>::Iterator iterator;
		typedef typename hash_bucket::HashTable<K, std::pair<const K, V>, MapKeyOfT, Hash>::ConstIterator const_iterator;

		// 使用这个也可以
		/*
		using iterator = typename hash_bucket::HashTable<K, std::pair<const K, V>, MapKeyOfT, Hash>::Iterator;
		using const_iterator = typename hash_bucket::HashTable<K, std::pair<const K, V>, MapKeyOfT, Hash>::ConstIterator;
		*/ 

		iterator begin()
		{
			return _ht.Begin();
		}

		iterator end()
		{
			return _ht.End();
		}

		const_iterator begin() const
		{
			return _ht.Begin();
		}

		const_iterator end() const
		{
			return _ht.End();
		}

		std::pair<iterator, bool> insert(const std::pair<K, V>& kv)
		{
			return _ht.Insert(kv);
		}

		V& operator[](const K& key)
		{
			std::pair<iterator, bool> ret = _ht.Insert({ key, V() });
			return ret.first->second;
		}

	private:
		hash_bucket::HashTable<K, std::pair<const K, V>, MapKeyOfT, Hash> _ht;
	};

	/////////////////测试/////////////
	// const迭代器
	void print(const unordered_map<std::string, std::string>& s)
	{
		unordered_map<std::string, std::string>::const_iterator it = s.begin();
		while (it != s.end())
		{
			//*it = 1;
			std::cout << it->first << " " << it->second << std::endl;
			++it;
		}
		std::cout << std::endl;
	}

	void unordered_map_Test()
	{
		unordered_map<std::string, std::string> s;
		s.insert({ "string", "字符串" });
		s.insert({ "left", "左" });

		unordered_map<std::string, std::string>::iterator it = s.begin();
		while (it != s.end())
		{
			std::cout << it->first << ":" << it->second << std::endl;
			++it;
		}

		print(s);

		s["sort"];
		s["left"] = "左边+剩余";
		s["right"] = "右边";

		// pair中的first不能被修改
		unordered_map<std::string, std::string>::iterator it2 = s.begin();
		while (it2 != s.end())
		{
			//it2->first += 'x';
			//it2->second += 'x';
			std::cout << it2->first << ":" << it2->second << std::endl;
			++it2;
		}
	}
}
C++ 哈希桶和封装unordered_map和unordered_set
puppy_1mo的博客
10-16 1157
编译器根本不认识_pht前面的代码前置声明。
【C++】哈希表封装unordered_set和unordered_map
春风不语。
11-19 1761
本篇到这里就结束了，主要讲了用哈希表封装unordered_set和unordered_map的详细过程，希望对大家有帮助，祝生活愉快！
【C++】unordered_set 和 unordered_map 使用 | 封装
qq_62939852的博客
05-27 2377
哈希桶HashBucket中需要将其内部的HashNode 的参数进行修改将原来的模板参数 K，V 改为 T同样由于不知道传入数据的是K还是K V类型的 ，所以 使用 T 类型的data代替之前实现的模板参数 K ，V分别代表 key 与value修改后 ， 第一个参数 拿到单独的K类型，是为了 使用 Find erase接口函数的参数为K第二个参数 T 决定了 拿到的是K类型 还是 K V 类型。
C++修炼：unordered_map和unordered_set的使用和封装
但凡的博客
05-31 994
unordered_set和unordered_map的封装
C++——STL——unordered_map与unordered_set的使用以及使用哈希表封装unordered_map/set
2402_86667364的博客
05-26 894
1.unordered_set的声明如上，Key就是unordered_set底层关键字的类型默认要求Key支持转换为整形，如果不支持或者想按自己的需求走可以自行实现支 持将Key转成整形的仿函数传给第二个模板参数t默认要求Key支持比较相等，如果不支持或者想按自己的需求走可以自行实现支持 将Key比较相等的仿函数传给第三个模板参数底层存储数据的内存是从空间配置器申请的，如果需要可以自己实现内存池，传给 第四个参数。5.⼀般情况下，我们都不需要传后三个模板参数。
C++进阶——用Hash封装unordered_map和unordered_set
2301_79830926的博客
01-06 748
本篇博客我会利用上一篇博客以链地址法实现的哈希表对unordered_map和unordered_set进行封装，大家如果想了解链地址法实现哈希表可以移步我的上一篇博客~C++进阶——哈希思想及实现-CSDN博客。
【C++】unordered_set、unordered_map详细封装细节
小羊的博客
10-18 2091
unordered_set和unordered_map的封装相较于set和map的封装还是相对较复杂的，其中复杂之处主要在于模版参数间的对应关系，如果某处做修改一般都会牵扯到多个地方，因此封装时必须时刻清晰各个板块之间的依赖关系。
【C++】封装unordered_set和unordered_map
weixin_64132124的博客
05-04 1089
【C++】通过红黑树封装map和set-CSDN博客这里我们就用之前的哈希表代码，继续在上面封装，将其封装为unordered_set和unordered_map。和红黑树封装一样，内容劲爆，老铁焖做好心理准备，我们开始了！终于又解决了一个大问题，这里我们C++的水平应该就很强了，之后我们要学习一些有关C++11的新特性，并进入Linux篇，继续学习关于信号等知识，大家敬请期待吧！
C++笔记---封装unordered_set和unordered_map
2302_80372340的博客
10-23 1250
unordered_set/unordered_map底层为哈希表，相比于底层为红黑树的set/map来说，数据无序但查找插入都更高效。要自己实现unordered_set/unordered_map，重点在于底层哈希表的实现，难点在于各个结构之间的相互嵌套，参数类型的传值，在自己实现的过程中一定会出现很多问题的。而且报出来的错误会让你觉得牛头不对马嘴，例如：这是由于end()后面加上了const而发生的报错，但感觉怎么想二者之间都没关系，真给我搞红温了。
C++STL详解(十) -- 使用哈希表封装unordered_set和unordered_map
清欢Allen的技术博客
04-25 985
(1):set模板参数要求能够支持小于比较,例如:二叉搜索树查找成员函数中,我们可以利用compare仿函数将当前结点值与所给值比较,从而决定cur遍历左子树还是右子树,为了能够支持大于比较的,我们可以交换一下实参位置,这也间接支持了大于比较.并且条件判断,进而也支持了等于.(1)针对于K类型(指针,打浮点数,有符号整型)可以转换为无符号整数取模.对于string,日期类类型,这两个类型与整型类型无关的,此时不可以直接强转为整数,需要相应的提供将该类型转换为整数的仿函数.
c++|unordered系列关联式容器(unordered_set、unordered_map介绍使用+哈希结构)
weixin_68201503的博客
06-09 1101
1.unordered_set与set一样元素key与value是一一对应的，且是唯一的,set中的key不能在容器中修改(元素总是const)，但是可以插入和删除,且元素是去重的。2.unordered_set与set不一样的是，其底层是由数组实现，数组存储的是，且节点值的顺序没有按照特定的顺序排序，为了能在常数范围内找到可以所对应的key，unordered_set将相同哈希值的键值对放在相同的桶中(比较抽象，待后续分析)。
C++ 使用哈希表封装模拟实现unordered_map unordered_set
TPON的博客
11-17 1011
C++实现哈希表封装unordered_map unordered_set
C++哈希表(unordered_map和unordered_set)
weixin_61488314的博客
12-29 1498
哈希表封装unordered_map和unordered_set具体步骤一、哈希表类1.定义桶节点，桶节点中包含存储的值和指向下一个桶节点的指针2.定义哈希表类，类中成员变量分别为一个数组，数组中的值指向一个桶的节点指针3.各类成员函数实现，通过两个DefaultHashFunc函数来获取key值所对应的整型值二、迭代器1.迭代器类需要两个成员变量分别为哈希表指针和桶节点指针2.实现迭代器的++，==和!=,指针,引用等操作。
（C++）（持续更新）C++期末复习重点补充
fly_jiangwb的博客
08-14 572
期末复习自用错题本
【C++】缺省参数
最新发布
leilei050213的博客
08-15 237
为函数的。
C++中的STL标准模板库和string
2301_79976271的博客
08-13 834
大致介绍了STL六大组件的基础构成，以及string类的功能及模拟实现
UE官方文档学习 C++ TAarry 查询（三）Contain，Find函数的使用
m0_64217692的博客
08-12 228
但ContainsByPredicate 不仅能判断，这个元素的长度，还能断言打日志。这里就使用Lamda函数值传递，一直对每个下标累加，标记。从头开始找，直到找到满足条件的就返回，为true。找不到就为false。可以从前面找或者后面找，返回下标。找到第一个，最好默认为-1。Contain只是判断是否有这个元素.
C++查找法超超超详细解析
正在在摸鱼的博客
08-13 1178
二叉排序树（BST）是一种动态数据结构左子树中所有节点的值小于根节点的值；右子树中所有节点的值大于根节点的值；左、右子树本身也是二叉排序树。节点结构int val;AVL树是最早提出的自平衡二叉搜索树，由Adelson-Velsky和Landis于1962年发明。其核心特性是每个节点的平衡因子（Balance Factor, BF）绝对值不超过1。平衡因子：BF(node) = 左子树高度 - 右子树高度。失衡条件：插入或删除操作导致某个节点的BF绝对值超过1（即BF=±2）。
C++ #if
qq_46279058的博客
08-15 184
（Preprocessor Directive），用于。，即在编译阶段根据条件决定是否包含某段代码。跨平台适配（Windows/Linux/macOS）如果条件成立（非零），则编译。（决定哪些代码参与编译）。被定义且非零，则输出。（编译时可确定的值）。防止头文件重复包含（
C++实现哈希表：unordered_map与自定义版本
总结起来，C++中的哈希表可以通过`std::unordered_map`轻松实现，而自定义哈希表需要考虑哈希函数、冲突解决、负载因子和扩容策略等多个方面。理解和掌握这些概念对于优化数据结构的性能至关重要。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

小林子AND

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

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

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

打赏作者

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

抵扣说明：

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

余额充值