unoredered_map&unordered_set封装

最新推荐文章于 2024-08-27 21:01:50 发布
最新推荐文章于 2024-08-27 21:01:50 发布
阅读量248 收藏 10
点赞数 4
分类专栏： C/C++语法 文章标签： c++ hash unordered_map unordered_set
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/li_peixiansang/article/details/141502279
版权

各层封装关系

封装时细节/tips

Rfr Ptr用来constiterator

//HTIterator 模板
template<class K, class T, class Ptr, class Rfr, class KeyOfT, class Hash>
class HTIterator

//普通Iterator类 & const_iterator类
typedef HTIterator<K, T, T*, T&, KeyOfT, Hash> Iterator;
typedef HTIterator<K, T, const T*, const T&, KeyOfT, Hash> ConstIterator;

hashtable中必须写const Begin & const End   ，因为cosntiterator和iterator是两个不同的类，不可自动转换

//错误， iterater & const_iterator不是同一类， 也没有强转函数， 不可转化
bit::HashTable<string, pair<string, string>>::ConstIterator it = ss.Begin();

//正确， 类型匹配
bit::HashTable<string, pair<string, string>>::ConstIterator it = ss.cBegin();

因子比较记得转成小数

//错误， 两整数相除， 结果还是整数， 误差较大
if (_n / _tables.size() >= 1)//扩容

//正确
if (double(_n) / _tables.size() >= 1)//扩容

HTIterator 构造函数， _ptr不可const， _pht 一定要const 为了 constiterator 初始化（传递 const this，要用 const hashtable类接收）

//iterator构造函数
HTIterator(HashNode<T>* p, const HashTable<K, T, KeyOfT, Hash>* pht):
	_ptr(p),
	_pht(pht)
{}

//iterator成员类型
HashNode<T>* _ptr = nullptr;
const HashTable<K, T, KeyOfT, Hash>* _pht;

函数名后的const只修饰this指针

在类中，const成员函数只能调用const成员函数，因为this指针存在

但可以调用非成员函数的非const函数（在保证不权限放大情况下）

源代码：

代码库链接：daily-practice-code: 存放日常练习的代码， 包括网课内容练习， 各种容器/算法模拟实现， I/O好题等

main.cpp

#include "unordered_map.h"
#include "unordered_set.h"
using namespace std;

void test_hash_bucket()
{
	bit::HashTable<string, pair<string, string>> ss;
	ss.Insert(make_pair("1", "one"));
	ss.Insert(make_pair("2", "two"));
	ss.Insert(make_pair("3", "three"));
	ss.Insert(make_pair("4", "four"));
	ss.Insert(make_pair("5", "five"));
	ss.Insert(make_pair("6", "six"));
	ss.Insert(make_pair("7", "sevent"));
	ss.Insert(make_pair("8", "eight"));
	ss.Insert(make_pair("9", "nine"));
	ss.Insert(make_pair("10 ", "ten"));
	ss.Insert(make_pair("11", "eleven"));
	ss.Insert(make_pair("12", "twelve"));
	ss.Insert(make_pair("13", "thirteen"));
	bit::HashTable<string, pair<string, string>>::ConstIterator it = ss.cBegin();
	while (it != ss.cEnd())
	{
		cout << it->first << ":" << it->second << endl;
		++it;
	}
	cout << "hello unordered" << endl;
}

void test_unordered_map()
{
	bit::unordered_map<string, string> ss;
	ss["1"] = "one";
	ss["2"] = "two";
	ss["3"] = "three";
	ss.insert(make_pair("4", "four"));
	ss.insert(make_pair("5", "five"));
	ss.insert(make_pair("6", "six"));
	ss.insert(make_pair("7", "seven"));
	bit::unordered_map<string, string>::iterator it = ss.begin();
	cout << "before erase:" << endl;
	for (const auto& e: ss)
	{
		cout << e.first << ":" << e.second << endl;
	}
	cout << "fine(\" 2\")" << ":" << ss.find("2")->second << endl;
	it = ss.erase(it);
	cout << "after erase" << endl;
	while (it != ss.end())
	{
		cout << it->first << ":" << it->second << endl;
		++it;
	}

	cout << "ss.bucket_count() == " << ss.bucket_count() << endl;
	cout << "bucket_size(2) == " << ss.bucket_size("2") << endl;
	cout << "hello unordered_map" << endl;
}

void test_unordered_set()
{
	bit::unordered_set<int> ss;
	ss.insert(1);
	ss.insert(2);
	ss.insert(3);
	ss.insert(4);
	ss.insert(5);
	ss.insert(6);
	ss.insert(7);
	ss.insert(8);
	ss.insert(9);
	ss.insert(10);
	ss.insert(11);
	bit::unordered_set<int>::iterator it = ss.begin();
	cout << "before erase:" << endl;
	for (const auto& e : ss)
	{
		cout << e << endl;
	}
	cout << "fine(\" 2\")" << ":" << *(ss.find(2)) << endl;
	it = ss.erase(it);
	cout << "after erase begin" << endl;
	while (it != ss.end())
	{
		cout<<(*it)<< endl;
		++it;
	}

	cout << "ss.bucket_count() == " << ss.bucket_count() << endl;
	cout << "bucket_size(2) == " << ss.bucket_size(2) << endl;
	cout << "successful, unordered_set" << endl;
}

int main()
{
	//test_hash_bucket();
	//test_unordered_map();
	test_unordered_set();
	return 0;
}

unordered_map.h

#include "hash_bucket.h"


namespace bit
{
	
	// unordered_map中存储的是pair<K, V>的键值对，K为key的类型，V为value的类型，HF哈希函数类型
	// unordered_map在实现时，只需将hashbucket中的接口重新封装即可
	template<class K, class V, class HF = HashFunc<K>>
	class unordered_map
	{
		
		// 通过key获取value的操作
		struct KeyOfValue
		{
			const K& operator()(const pair<K, V>& data)
			{
				return data.first;
			}
		};
		typedef bit::HashTable<K, pair<K, V>, KeyOfValue, HF> HT;
	public:
		typedef typename HT::Iterator iterator;
		typedef typename HT::ConstIterator const_iterator;
	public:
		unordered_map() : _ht()
		{}
		
		iterator begin() { return _ht.Begin(); }
		iterator end() { return _ht.End(); }
		
		// capacity
		size_t size()const { return _ht.size(); }
		bool empty()const { return _ht.empty(); }
		///
		// Acess
		V& operator[](const K& key)
		{
			pair<iterator, bool> ret = _ht.InsertUnique(pair<K, V>(key, V()));
			return ret.first->second;
		}
		const V& operator[](const K& key)const
		{
			pair<iterator, bool> ret = _ht.InsertUnique(pair<K, V>(key, V()));
			return ret.fisrt->second;
		}
		//
		// lookup
		iterator find(const K& key) { return _ht.Find(key); }
		size_t count(const K& key) { return _ht.Count(key); }
		/
		// modify
		pair<iterator, bool> insert(const pair<K, V>& valye)
		{
			return _ht.InsertUnique(valye);
		}

		iterator erase(iterator position)
		{
			return _ht.Erase(position);
		}
		
		// bucket
		size_t bucket_count() { return _ht.UnemptyBucketCount(); }
		size_t bucket_size(const K& key) { return _ht.BucketSize(key); }
	private:
		HT _ht;
	};
}

unoredered_set.h

#pragma once
#include "hash_bucket.h"

namespace bit
{
	

	// unordered_set中存储的是K类型，HF哈希函数类型
	// unordered_set在实现时，只需将hashbucket中的接口重新封装即可
	template<class K, class HF = HashFunc<K>>
	class unordered_set
	{
		// 通过key获取value的操作
		struct KeyOfValue
		{
			const K& operator()(const K& data)
			{
				return data;
			}
		};
		typedef bit::HashTable<K, K, KeyOfValue, HF> HT;
	public:
		typedef typename HT::Iterator iterator;
		typedef typename HT::ConstIterator const_iterator;
	public:
		unordered_set() : _ht()
		{}
		
		iterator begin() { return _ht.Begin(); }
		iterator end() { return _ht.End(); }
		
		// capacity
		size_t size()const { return _ht.size(); }
		bool empty()const { return _ht.empty(); }
		///
		// lookup
		iterator find(const K& key) { return _ht.Find(key); }
		size_t count(const K& key) { return _ht.Count(key); }
		/
		// modify
		pair<iterator, bool> insert(const K& value)
		{
			return _ht.InsertUnique(value);
		}

		iterator erase(iterator position)
		{
			return _ht.Erase(position);
		}
		
		// bucket
		size_t bucket_count() { return _ht.UnemptyBucketCount(); }
		size_t bucket_size(const K& key) { return _ht.BucketSize(key); }
	private:
		HT _ht;
	};
}

hash_bucket.h

#pragma once
#pragma once
#include <iostream>
#include <string>
#include <assert.h>
#include <vector>
using namespace std;

template <class T, class K>//默认pair
struct KOT
{
	K operator()(const T& kv)
	{
		return kv.first;
	}
};


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

// 哈希表中支持字符串的操作
template<>
struct HashFunc<string>
{
	size_t operator()(const string& key)
	{
		return stoi(key);
		size_t hash = 0;
		for (auto e : key)
		{
			hash *= 31;
			hash += e;
		}

		return hash;
	}
};

namespace bit
{
	template<class T>
	struct HashNode
	{
		T _data;
		HashNode<T>* _next;
		HashNode(const T& data)
			:_data(data)
			, _next(nullptr)
		{}
	};

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

	template<class K, class T, class Ptr, class Rfr, class KeyOfT, class Hash>
	class HTIterator
	{
		typedef HTIterator<K, T, Ptr, Rfr, KeyOfT, Hash> Self;
	public:
		HTIterator(HashNode<T>* p, const HashTable<K, T, KeyOfT, Hash>* pht):
			_ptr(p),
			_pht(pht)
		{}
		Rfr operator*()
		{
			return _ptr->_data;
		 }
		Self operator++()
		{
			decltype(_ptr) cur = _ptr->_next;
			if (cur)//cur不为空
			{
				_ptr = cur;
				return Self(_ptr, _pht);
			}
			//cur为空
			size_t int_key = hash(kot(_ptr->_data));
			int_key %= _pht->_tables.size();
			int_key++;
			while (int_key < _pht->_tables.size())
			{
				if (_pht->_tables[int_key])//不为空
				{
					_ptr = _pht->_tables[int_key];
					return Self(_ptr, _pht);
				}
				int_key++;
			}
			_ptr = nullptr;
			return Self(nullptr, _pht);
		}
		Ptr operator->()
		{
			return &(_ptr->_data);
		 }

		bool operator==(const Self& other) const
		{
			return _ptr == other._ptr;
		}
		bool operator!=(const Self other) const
		{
			return _ptr != other._ptr;
		}

	private:
		HashNode<T>* _ptr = nullptr;
		const HashTable<K, T, KeyOfT, Hash>* _pht;
		Hash hash;
		KeyOfT kot;
	};

	// K 为 T 中key的类型
	// T 可能是键值对，也可能是K
	// KeyOfT: 从T中提取key
	// Hash将key转化为整形，因为哈市函数使用除留余数法
	template<class K, class T, class KeyOfT = KOT<T, K>, class Hash = HashFunc<K>>
	class HashTable
	{
		template<class K, class T,class Ptr, class Rfr, class KeyOfT, class Hash >
		friend class HTIterator;
		typedef HashNode<T> Node;
	public:
		typedef HTIterator<K, T, T*, T&, KeyOfT, Hash> Iterator;
		typedef HTIterator<K, T, const T*, const T&, KeyOfT, Hash> ConstIterator;

		HashTable()
		{
			_tables.resize(10, nullptr);
		}

		// 哈希桶的销毁
		~HashTable()
		{
			for (auto e : _tables)
			{
				while (e)
				{
					auto next = e->_next;
					delete e;
					e = next;
				}
			}
		}

		// 插入值为data的元素，如果data存在则不插入
		bool Insert(const T& data)
		{
			if (Find(kot(data))!= Iterator(nullptr, this)) return false;
			if (double(_n) / _tables.size() >= 1)//扩容
			{
				HashTable<K, T, KeyOfT, Hash> new_hash;
				new_hash._tables.resize(_tables.size() * 2);
				for (auto e : _tables)
				{
					while (e)
					{
						new_hash.Insert(e->_data);
						e = e->_next;
					}
				}
				_tables.swap(new_hash._tables);
				Insert(data);
				return true;
			}
			Node* ptr = new Node(data);
			int key = hash(kot(data));
			key %= _tables.size();
			ptr->_next = _tables[key];
			_tables[key] = ptr;
			_n++;
			return true;
		}

		pair<Iterator, bool> InsertUnique(const T& data)
		{
			if (Find(kot(data)) != Iterator(nullptr, this)) return make_pair(Find(kot(data)),false);
			if (double(_n) / _tables.size() >= 1)//扩容
			{
				HashTable<K, T, KeyOfT, Hash> new_hash;
				new_hash._tables.resize(_tables.size() * 2);
				for (auto e : _tables)
				{
					while (e)
					{
						new_hash.Insert(e->_data);
						e = e->_next;
					}
				}
				_tables.swap(new_hash._tables);
				
				return make_pair(InsertUnique(data).first, true);
			}
			Node* ptr = new Node(data);
			int key = hash(kot(data));
			key %= _tables.size();
			ptr->_next = _tables[key];
			_tables[key] = ptr;
			_n++;
			return make_pair(Iterator(ptr, this), true);
		}

		// 在哈希桶中查找值为key的元素，存在返回true否则返回false
		Iterator Find(const K& key)
		{
			int int_key = hash(key);
			int_key %= _tables.size();
			auto ptr = _tables[int_key];
			while (ptr)
			{
				if (kot(ptr->_data) == key) return Iterator(ptr, this);
				ptr = ptr->_next;
			}
			return Iterator(nullptr, this);
		}

		// 哈希桶中删除key的元素，删除成功返回true，否则返回false
		pair<Iterator, bool> Erase(const K& key)
		{
			if (Find(key)== End()) return make_pair(Iterator(nullptr, this), false);//找不到key
			//存在key
			int int_key = hash(key);
			int_key %= _tables.size();
			auto ptr = _tables[int_key];
			Node* prev = ptr;
			while (ptr)
			{
				if (kot(ptr->_data) == key)
				{//ptr为要删除结点
					if (prev == ptr)//ptr为头节点
					{
						_tables[int_key] = ptr->_next;
					}
					else prev->_next = ptr->_next;
					Iterator it(ptr, this);
					++it;
					delete ptr;
					_n--;
					return make_pair(it, true);
				}
				prev = ptr;
				ptr = ptr->_next;
			}
			//找不到删除节点
			return make_pair(Iterator(nullptr, this), false);
		}

		Iterator Erase(Iterator it)
		{
			return Erase(kot(*it)).first;
		}

		size_t size() const
		{
			return size_t(_n);
		}

		bool empty() const
		{
			return _n == 0;
		}

		size_t Count(const K& key) 
		{
			size_t ret = 0;
			Iterator it = Begin();
			while (it != End())
			{
				if (it->first == key)
				{
					ret++;
				}
				++it;
			}
			return ret;
		}

		size_t TotalBucketCount()
		{
			return _tables.size();
		}

		size_t UnemptyBucketCount()
		{
			size_t ret = 0;
			for (const auto& e : _tables)
			{
				if (e) ++ret;
			}
			return ret;
		}

		size_t BucketSize(const K& key)
		{
			int int_key = hash(key);
			Node* cur = _tables[int_key];
			size_t ret = 0;
			while (cur)
			{
				ret++;
				cur = cur->_next;
			}
			return ret;
		}

		Iterator Begin()
		{
			int cur = 0;
			while (cur < this->_tables.size())
			{
				if (_tables[cur])
				{
					return Iterator(_tables[cur], this);
				}
				cur++;
			}
			return End();
		}

		ConstIterator cBegin() const
		{
			int cur = 0;
			while (cur < this->_tables.size())
			{
				if (_tables[cur])
				{
					return ConstIterator(_tables[cur], this);
				}
				cur++;
			}
			return cEnd();
		}

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

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

		void Print(const string& str = "")
		{
			cout << str << endl;
			for (auto e : _tables)
			{
				while (e)
				{
					cout << e->_data.first << ":" << e->_data.second << endl;
					e = e->_next;
				}
			}
		}

	private:
		vector<Node*> _tables;  // 指针数组
		size_t _n = 0;			// 表中存储数据个数
		KeyOfT kot;
		Hash hash;
	};
}

lisanndesu
关注
  • 4
    点赞
  • 踩
  • 10
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
初识C++之unordered_map与unordered_set
Masquerena114514的博客
04-07 2143
本文主要讲述了通过对哈希桶的改造，使得unordered_set和unordered_map能够对同一个哈希桶进行封装并模拟实现
模拟实现unordered_map和unordered_set超详解（C++）
m0_67430750的博客
05-19 2184
模拟实现unordered_map、unordered_set超详解，包括哈希表以及unordered_map、unordered_set完整代码，迭代器封装、功能测试等。
【C++ STL】unordered_map&unordered_set (哈希表）
Z1tai的博客
08-08 991
哈希也叫做散列，记数排序就体现了哈希思想。计数排序为统计数字出现的个数，为每个数字都开辟了对应的一块空间，用来记录其出现的个数，每遇到就加一。将一个元素和一个位置建立映射关系，这就是哈希的本质。常见的数据类型如整数，库中自带哈希函数，但有些类型比如自定义类型，需要我们自定义哈希函数。可以把哈希函数设计成仿函数，对不同类型添加特化处理。return key;// 特化template<>//BKDRreturn val;
unordered_map和unordered_set
m0_69323023的博客
02-04 1770
unordered_map和unordered_set
【C++】Unordered_map && Unordered_set
NeeEk0的博客
03-07 1159
本篇博客unordered_map和unordered_set的特性和常见用法，并搭配对STL源码的模拟实现，旨在更好地帮助读者理解容器的功能。
STL——模拟封装unordered_map&unordered_set
m0_63020222的博客
03-30 178
模拟封装unordered_map和unordered_set
C++ 使用哈希表封装模拟实现unordered_map unordered_set
TPON的博客
11-17 796
C++实现哈希表封装unordered_map unordered_set
【手撕STL】unordered_set、unordered_map(用哈希表封装)
AI_ELF的博客
07-11 1574
unordered_map在线文档说明 注意：unordered_set在线文档说明注：在功能上和map、set是一样的区别在于，这两个容器遍历出来不是有序的，他们是单向迭代器 运行结果： 注：unordered系列的关联式容器之所以效率比较高，是因为其底层使用了哈希结构。总结：注： 当存储的数据没有特定说明需要排序时，一定要用unordered系列的关联式容器；当需要存储的序列为有序时，应该选用ordered系列的关联式容器对于两个数据元素的关键字 ki和kj (i != j)，有ki !=kj ，但有：
C++进阶：封装unordered_map和unordered_set以及海量数据面试题
碧瑶的博客呀
11-19 397
使用哈希桶对unordered_map和unordered_set进行封装、海量数据面试题（位图的介绍、布隆过滤器、倒排索引）、unordered_map与map的相同和不同
【C++】链表
qq_38801607的博客
08-22 569
链表是一种常见的动态数据结构，与数组相比，它在插入和删除操作中具有更高的效率。链表的每个元素称为节点（Node），节点包含两个部分：数据域（存储数据）和指针域（指向下一个节点的指针）。链表的最大特点是节点的内存位置不需要连续，可以通过指针来链接在一起。
C++ 重载运算符和重载函数
lly202406的博客
08-25 482
在C++编程语言中，运算符重载和函数重载是两个非常核心的概念，它们允许开发者扩展或重新定义运算符和函数的行为，以适应特定的数据类型或对象。本文将详细探讨C++中的运算符重载和函数重载，包括它们的基本概念、使用场景、实现方式以及注意事项。
c语言用if语句制作点单程序
2301_81968528的博客
08-20 304
printf("数字1代表喝咖啡，数字2代表喝雪碧:");这里的点单程序是用户输入相应的数字自动出来相应的饮品。puts("您要喝的是咖啡");puts("您要喝雪碧");比如输入1是咖啡，输入2是雪碧。c语言里面，if语句的语法是。
初识顺序表---C语言
weixin_74202161的博客
08-23 343
顺序表是一种以数组为基础的结构，对数组进行封装，实现常用的增删改查等操作的。//销毁。
Dijkstra(c++)
weixin_73378557的博客
08-24 491
迪杰斯特拉算法(Dijkstra)是由荷兰计算机科学家狄克斯特拉于1959年提出的，因此又叫狄克斯特拉算法。是从一个顶点到其余各顶点的最短路径算法，解决的是有权图中最短路径问题。迪杰斯特拉算法主要特点是从起始点开始，采用贪心算法的策略，每次遍历到始点距离最近且未访问过的顶点的邻接节点，直到扩展到终点为止。同时dijkstra算法主要用于解决单源最短路问题（边权为正数），其可以分为两种版本，两种版本各有用处，并不存在好坏之分，接下来我们用n代表点的数量，用m代表边的数量。
C语言01 每日一练01
小蜗的房子
08-24 1217
C语言01 每日一练01
坐牢第三十天（c++）
m0_62828714的博客
08-27 282
提示并输入一个字符串，统计该字符串中字母个数、数字个数、空格个数、其他字符的个数 效果图：
C++：list篇
最新发布
2301_80894970的博客
08-27 585
我们可以看到，当erase后如果在对it迭代器进行操作，vs则会进行强制检查(根据编译环境不同，处理环境也不相同),则不允许再继续使用,如果想继续使用的话，C++同样也给出了方案，可以看到erase会返回一个迭代器，而返回的迭代器就是下一个链表的位置。那么从上面的begin与end可以看出，使用迭代器遍历list，仅仅只需要解引用迭代器以及++迭代器就能取得我们想要的值与让迭代器走向下一个节点，那么有没有想过一个问题，list的迭代器与vector这种类似数组的迭代器底层是否是一样的呢？
【C++】类与对象
2401_82855612的博客
08-24 345
C++编译器给每个非静态的成员函数增加了一个隐藏的指针参数即this指针让该指针指向当前对象(函数运行时调用该函数的对象)，在函数体中所有“成员变量”的操作，都是通过该指针去访问。只需要计算成员变量的大小（注意内存对齐），不需要计算成员函数的大小，无论定义多少对象，成员函数就只有一个是公用的. 编译器给了空类一个字节来唯一标识这个类的对象。如果嵌套了结构体的情况，嵌套的结构体对齐到自己的最大对齐数的整数倍处，结构体的整 体大小就是所有最大对齐数（含嵌套结构体的对齐数）的整数倍。
unordered_map 头文件
07-28
unordered_map 头文件是 `<unordered_map>`。\[1\] 你可以通过包含这个头文件来使用 unordered_map 容器。 #### 引用[.reference_title] - *1* [C++中的unordered_map](https://blog.csdn.net/qq_19432525/article/details/130901364)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v91^insertT0,239^v3^insert_chatgpt"}} ] [.reference_item] - *2* [C++语法—— STL:unordered_map](https://blog.csdn.net/caijige/article/details/127145508)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v91^insertT0,239^v3^insert_chatgpt"}} ] [.reference_item] - *3* [【C++】unordered_set 和 unordered_map 使用 | 封装](https://blog.csdn.net/qq_62939852/article/details/130896774)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v91^insertT0,239^v3^insert_chatgpt"}} ] [.reference_item] [ .reference_list ]
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值