1. Toy模板网首页
  2. > Toy博客

C++STL详解(十) -- 使用哈希表封装unordered_set和unordered_map

7月前 作者：清欢Allen 分类：Toy博客 阅读(36) 违法举报

这篇具有很好参考价值的文章主要介绍了C++STL详解(十) -- 使用哈希表封装unordered_set和unordered_map。希望对大家有所帮助。如果存在错误或未考虑完全的地方，请大家不吝赐教，您也可以点击"举报违法"按钮提交疑问。

哈希表模板参数改造

针对模板参数V改造

因为不同容器的类型不同,如果是unordered_map,V代表一个键值对,如果unordered_set,V代表Key值,而底层哈希表并不知道上层容器所要传递的V模板参数类型,为了与哈希表的模板参数区分,我们将哈希表中的V模板参数改为T.
C++STL详解(十) -- 使用哈希表封装unordered_set和unordered_map

增加仿函数获取具体数据类型.

例如: 在哈希表中当我们使用Find函数进行查找时:
如果上层传递的数据类型为Key值,我们就可以直接与查找数据比较.
如果上层传递的数据类型为pair<K,V>键值对,我们就不可以直接比较,需要利用仿函数获取键值对的first进行比较.
unordered_set仿函数SetKeyOfT代码:

struct SetKeyOfT              //根据map还是set传递不同数据类型给底层.
		{
			const K& operator()(const K& key)
			{
				return key;
			}
		};

unordered_map仿函数MapKeyOfT代码:

struct MapKeyOfT                   //根据map还是set传递不同数据类型给底层.
		{
			const K& operator()(const pair<K, V>& kv)
			{
				return kv.first;   //获取pair<K,V>键值对中的first.
			}
		};

所以,我们要在哈希表模板参数中增加一个仿函数KeyOfT.
如果是unordered_set,就传 SetKeyOfT类型的仿函数.
如果是unordered_map,就传MapKeyOfT类型的仿函数.

模板参数转换图示如下:
C++STL详解(十) -- 使用哈希表封装unordered_set和unordered_map
额外说明:
1: 我们对原先哈希表中的Hash进行了修改,不要缺省值,因为我们肯定是使用上层容器传递不同的仿函数类型,所以在unordered_set与unordered_map中传递仿函数类型.

哈希表的正向迭代器

正向迭代器中的内置成员:

哈希表正向迭代器有两个内置成员:
1: 结点指针
2: 哈希表的指针


template < class K, class T, class Hash, class KeyOfT >
class HashTable;                   //重新声明哈希表类模板.
//正向迭代器
template<class K, class T, class KeyOfT, class HashFunc = Hash<K>>
struct __HTIterator
{
	typedef HashNode<T> Node; //重新定义哈希结点的类型为Node.
	typedef HashTable<K, T, KeyOfT, HashFunc> HT; //重新定义哈希表的类型为HT.
	typedef __HTIterator<K, T, KeyOfT, HashFunc> Self; //重新定义正向迭代器的类型为Self.

	Node* _node; //结点指针
	HT* _pht; //哈希表指针
};

注意:
因为迭代器中要使用到哈希表类型,所以我们在哈希表迭代器前面必须声明一下哈希表类模板.

正向迭代器的成员函数

以下成员函数较为简单,就不另外说明:


		_HashIterator( Node* node,HT* pht )  //初始化列表
			:_node(node)
			, _pht(pht)
		{
		}
        
		T& operator*()                     //解引用运算符重载
		{
			return _node->_data;
		}

		T* operator->()                 //->运算符重载
		{
			return &_node->_data;
		}

		bool operator!=( const Self& s ) const  //外面增加const可以使const对象也能调用该成员函数.
		{
			return _node != s._node;  //实质上是迭代器中的_node比较
		}


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

前置++运算符重载:
前置++运算符重载主要有两个步骤:
1: 如果当前结点指针的下一个结点存在,则结点指针指向下一个结点.

2: 如果当前结点指针的下一个结点不存在:
(1): 通过哈希函数计算哈希桶的位置.

(2): 在哈希表中,从哈希桶中的下一个位置开始遍历查找.
如果哈希桶存在,则将结点指针指向该哈希桶.
如果哈希表遍历完还没有找到,则说明这是哈希表中的最后一个数据的迭代器,则结点指针指向空,表明最后一个数据的下一个结点.

Self& operator++()
		{
			if (_node->_next)  //在当前桶中迭代
			{
				_node = _node->_next;
			}
			                  //如果该哈希桶迭代完毕，则在哈希表中找下一个哈希桶迭代寻找．
			else
			{
				KeyOfT kot;
				Hash hash;
				size_t hashi = hash(kot(_node->_data)) % _pht->_table.size(); //迭代器访问哈希表的私有成员
				size_t i = hashi + 1;
				
				for (;  i < _pht->_table.size(); ++i)
				{
					if (_pht->_table[i])
					{
						_node = _pht->_table[i];
						break;                       //++完就退出.
					}
			        
				}
				if (i == _pht->_table.size())        //此时,这也说明正式哈希桶迭代器的end.
				{
					_node = nullptr;
				}

			}

			return *this;
		}

哈希表插入函数的修改(适用于unordered_map)

为了支持unordered_map中的[]操作符重载,我们针对哈希表中的插入函数返回值进行修改
(1): 如果哈希表中已有所给数据,则返回已有数据的迭代器与插入结果(失败)所构成的键值对.

(2): 如果哈希表没有所给数据,则将新数据头插该哈希桶组成的单链表上,返回新插入结点指针构造与插入结果(成功)组成的键值对.

插入函数代码如下:


	      pair< Iterator,bool> Insert(const T& data)
		   {
			Hash hash;
			KeyOfT kot;		                                                   
			Iterator ret = Find(kot(data));                    
			if (ret != end())
			{
				return make_pair( ret, false);
			}
			if (_size == _table.size())                                //扩容.
			{
				//	size_t newSize = _table.size() == 0 ? 10 : 2 * _table.size();
				vector<Node*> newTable;
				newTable.resize(GetNextPrime(_table.size()), nullptr); 

				Hash hash;
				//从旧表结点移动映射新表.
				for (size_t i = 0; i < _table.size(); ++i)
				{
					Node* cur = _table[i];
					while (cur)
					{
						Node* next = cur->_next;

						size_t hashi = hash(kot(cur->_data)) % newTable.size();
						cur->_next = newTable[hashi];
						newTable[hashi] = cur;

						cur = next;
					}
					_table[i] = nullptr;
				}
				_table.swap(newTable);
               
			}
			size_t hashi = hash(kot(data)) % _table.size();
			Node* newNode = new Node(data);
			newNode->_next = _table[hashi];
			_table[hashi] = newNode;
			++_size;
			return make_pair(Iterator(newNode,this),true);                //如果是新插入的数据,则返回新插入结点构造的迭代器与插入结果组成的pair.
		}

一个类型K去做set和unordered_set他的模板参数的必备条件.

set容器模板参数:
(1):set模板参数要求能够支持小于比较,例如:二叉搜索树查找成员函数中,我们可以利用compare仿函数将当前结点值与所给值比较,从而决定cur遍历左子树还是右子树,为了能够支持大于比较的,我们可以交换一下实参位置,这也间接支持了大于比较.并且条件判断,进而也支持了等于.
unordered_set容器模板参数要求:
(1)针对于K类型(指针,打浮点数,有符号整型)可以转换为无符号整数取模.对于string,日期类类型,这两个类型与整型类型无关的,此时不可以直接强转为整数,需要相应的提供将该类型转换为整数的仿函数.

(2):K类型对象能够支持等于比较(因为在查找中就是要确定存储的对象与所传的对象是否相等,例如Data日期类),如果不支持需要额外提供等于比较的仿函数.

unordered_set的模拟实现(完整代码)

在上述中,我们已经将unordered_set重点内容讲解完毕,剩下的成员函数只需要复用哈希表中的就可以了.

namespace yzh
{
	//2:因为我们使用map,set是将实参传给,map,set的所以当string类型取模时要在map,set中写仿函数.
	template < class K,class Hash = HashFunc<K>> //1:由第二个模板参数决定要存储的数据.
	class unordered_set
	{
		struct SetKeyOfT                                  //根据map还是set传递不同数据类型给底层.
		{
			const K& operator()(const K& key)
			{
				return key;
			}
		};
	public:
		typedef typename HashBucket::HashTable< K,K,Hash,SetKeyOfT>::Iterator iterator;  //重新定义一下迭代器类型为iterator.

		iterator begin()
		{
			return _ht.begin();
		}
		iterator end()
		{
			return _ht.end();
		}
		
		pair<iterator,bool> Insert(const K& key)
		{
			return _ht.Insert(key);
		}
	private:
		HashBucket::HashTable<K,K,Hash,SetKeyOfT> _ht;
	};
	void test_set()                      //测试
	{
		unordered_set<int> set;
		set.Insert(1);
		set.Insert(2);
		set.Insert(3);
		
		unordered_set<int>::iterator it = set.begin();
		while ( it != set.end() )
		{
			cout << *it << " ";
			++it;
		}
		cout << endl;
	}
	
}

unordered_map的实现(完整代码)

在上述中,我们已经将unordered_map重点内容讲解完毕,剩下的成员函数只需要复用哈希表中的就可以了.文章来源地址https://www.toymoban.com/news/detail-428808.html

namespace yzh
{
	template < class K, class V, class Hash = HashFunc<K> >            //由第二个模板参数决定要存储的数据类型,
	class unordered_map
	{
		struct MapKeyOfT                                             //根据map还是set传递不同数据类型给底层.
		{
			const K& operator()(const pair<K, V>& kv)
			{
				return kv.first;
			}
		};
		
	public:
		typedef typename HashBucket::HashTable< K, pair<K, V>, Hash, MapKeyOfT>::Iterator iterator;//重新定义一下迭代器类型为iterator.
		iterator begin()
		{
			return _ht.begin();
		}
		iterator end()
		{
			return _ht.end();
		}
	   pair<iterator,bool> Insert( const pair<K, V>& kv )
		{
			return _ht.Insert(kv);
		}
	   V& operator[]( const K& key  )                      //给一个key,返回V的引用.
	   {
		   pair<iterator, bool> ret = _ht.Insert(make_pair(key, V()));   //如果插入失败,返回已有数据的迭代器与返回结果组成的pair.                                                 //如果插入成功,返回新插入数据的迭代器与返回结果组成的pair.
		   return ret.first->second;
	   }
	   
	private:
		HashBucket::HashTable<K, pair<K, V>, Hash, MapKeyOfT> _ht;     //map和set都知道传递什么来类型的仿函数,以及要传递的数据类型.
	};
	void test_map()
	{
		unordered_map<string, string> dict;
		dict.Insert(make_pair("sort", "排序"));
		dict.Insert(make_pair("string", "排序"));

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

	void testmap1()
	{
		unordered_map<string, int> countMap;
		string arr[] = { "苹果","西瓜","苹果","西瓜","苹果","西瓜","苹果","香蕉" };
		for (auto& e : arr)
		{
			countMap[e]++;
		}

		for (auto& kv : countMap)
		{
			cout << kv.first << ":" << kv.second << endl;
		}
    }


	
}

适用于unordered_set和unordered_map的哈希表代码

#include <map>
#include <vector>
#include <string>
#include <string>
#include <iostream>
using namespace std;
template < class K >                   //仿函数的默认值,如果不显示传就会默认调用.
struct HashFunc
{
	size_t operator()(const K& key)
	{
		return (size_t)key;
	}
};

template< >                                 //1:对于常见类型,为了方便,我们可以对类模板进行特化.
struct HashFunc <string>                    //并且根据实参所传类型,优先走特化版本.	                                     
{
	size_t operator()(const string& key)
	{
		size_t  val = 0;
		for (auto& ch : key) //遍历string,将一个个字母替换成ASCI码进行相加.
		{
			val += ch;
		}
		return val;
	}
};
namespace HashBucket
{

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

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

	template < class K, class T, class Hash, class KeyOfT >
	class HashTable;
	
	template < class K, class T, class Hash, class KeyOfT >
	struct _HashIterator
	{
		typedef HashNode<T> Node;
		typedef HashTable< K, T, Hash, KeyOfT> HT;
		typedef _HashIterator< K, T, Hash, KeyOfT> Self;
		Node* _node;
	    HT* _pht;
		
		_HashIterator( Node* node,HT* pht )
			:_node(node)
			, _pht(pht)
		{
		}
        
		T& operator*()
		{
			return _node->_data;
		}

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

		Self& operator++()
		{
			if (_node->_next)  //在当前桶中迭代
			{
				_node = _node->_next;
			}
			                  //如果该哈希桶迭代完毕，则在哈希表中找下一个哈希桶迭代寻找．
			else
			{
				KeyOfT kot;
				Hash hash;
				size_t hashi = hash(kot(_node->_data)) % _pht->_table.size(); //迭代器访问哈希表的私有成员
				size_t i = hashi + 1;
				
				for (;  i < _pht->_table.size(); ++i)
				{
					if (_pht->_table[i])
					{
						_node = _pht->_table[i];
						break;                       //++完就退出.
					}
			        
				}
				if (i == _pht->_table.size())        //此时,这也说明正式哈希桶迭代器的end.
				{
					_node = nullptr;
				}

			}

			return *this;
		}

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


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

		
	};
	
	template < class K, class T, class Hash, class KeyOfT >
	struct HashTable
	{
		typedef HashNode<T> Node;
		template < class K, class T, class Hash, class KeyOfT > //为了迭代器能够访问哈希表的私有成员,我们设为迭代器是哈希表的
		                                                        //友元,类模板声明友元需要增加类模板.
		friend struct  _HashIterator;
		
	public:
		typedef _HashIterator< K, T, Hash, KeyOfT> Iterator;
		
		Iterator begin()//获取第一个迭代器
		{
			for (size_t i = 0; i < _table.size(); ++i)
			{
				if (_table[i])
				{
					return Iterator( _table[i], this );
				}
			}
			return end();
		}

		Iterator end()  //获取最后一个迭代器
		{
			return Iterator(nullptr, this);
		}

		size_t GetNextPrime(size_t prime)
		{
			const int PRIMECOUNT = 28;
			//素数序列
			const size_t primeList[PRIMECOUNT] =
			{
				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
			};
			size_t i = 0;
			for (i = 0; i < PRIMECOUNT; i++)
			{
				if (primeList[i] > prime)         //从这个数组里面取第一个大于prime的值.
					return primeList[i];
			}
			return primeList[i];                 //虽然数据不可能那么大,但是也有可能不会走if判断,
												 // 所以从语法上来说还要考虑所给值prime大于素数数组整个数据的情况.
		}

		~HashTable()         //vvector会调用析构函数,但是哈希桶必须自己写.
		{
			for (size_t i = 0; i < _table.size(); ++i)
			{
				Node* cur = _table[i];
				while (cur)
				{
					Node* next = cur->_next;
					delete cur;
					cur = next;
				}
				_table[i] = nullptr;
			}
			//	cout << "~HushTable()" << endl;

		}

		bool  Erase(const K& key)
		{
			if (_table.size() == 0)
			{
				return true;
			}
			Hash hash;
			size_t hashi = hash(key) % _table.size();
			Node* prev = nullptr;
			Node* cur = _table[hashi];
			while (cur)
			{
				if (cur->_kv.first == key)
				{
					if (prev == nullptr)
					{
						_table[hashi] = cur->_next;
					}
					else
					{
						prev->_next = cur->_next;
					}
					delete cur;
					--_size;
					return true;
				}

				prev = cur;
				cur = cur->_next;
			}
			return false;
		}

	      pair< Iterator,bool> Insert(const T& data)
		   {
			Hash hash;
			KeyOfT kot;
			
			                                                   //去重
			Iterator ret = Find(kot(data));                    //如果该数据已经有了,则返回已有数据的迭代器与插入结果构成的pair.
			if (ret != end())
			{
				return make_pair( ret, false);
			}
			if (_size == _table.size())                                //扩容.
			{
				//	size_t newSize = _table.size() == 0 ? 10 : 2 * _table.size();
				vector<Node*> newTable;
				newTable.resize(GetNextPrime(_table.size()), nullptr);    //扩容

				Hash hash;
				//从旧表结点移动映射新表.
				for (size_t i = 0; i < _table.size(); ++i)
				{
					Node* cur = _table[i];
					while (cur)
					{
						Node* next = cur->_next;

						size_t hashi = hash(kot(cur->_data)) % newTable.size();
						cur->_next = newTable[hashi];
						newTable[hashi] = cur;

						cur = next;
					}
					_table[i] = nullptr;
				}
				_table.swap(newTable);
               
			}
			size_t hashi = hash(kot(data)) % _table.size();
			Node* newNode = new Node(data);
			newNode->_next = _table[hashi];
			_table[hashi] = newNode;
			++_size;
			return make_pair(Iterator(newNode,this),true);                //如果是新插入的数据,则返回新插入结点构造的迭代器与插入结果组成的pair.
		}

	     Iterator Find(const K& key)
		{
			if (_table.size() == 0)        //表为空,就返回nullptr.
			{
				return end();
			}
			Hash hash;
			KeyOfT kot;
			size_t hashi = hash(key) % _table.size();
			Node* cur = _table[hashi];
			while (cur)
			{
				if (kot(cur->_data) == key)
				{
					return Iterator(cur, this);
				}
				cur = cur->_next;
			}
			return end();
		}

		size_t size()
		{
			return _size;
		}
		size_t TablesSize()          //表的长度
		{
			return  _table.size();
		}

		size_t BucketNum()           //有多少个桶被用了.
		{
			size_t Num = 0;
			for (size_t i = 0; i < _table.size(); ++i)
			{
				if (_table[i])
				{
					++Num;
				}
			}
			return Num;
		}
		size_t MaxBucketLenth()
		{
			size_t maxLen = 0;
			for (size_t i = 0; i < _table.size(); ++i)
			{
				size_t len = 0;
				Node* cur = _table[i];
				while (cur)
				{
					++len;
					cur = cur->_next;
				}
				if (len > maxLen)
				{
					maxLen = len;
				}
			}
			return maxLen;
		}
	private:
		vector<Node*> _table;
		size_t _size = 0;
	};
}

到了这里，关于C++STL详解(十) -- 使用哈希表封装unordered_set和unordered_map的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处： 如若内容造成侵权/违法违规/事实不符，请点击违法举报进行投诉反馈，一经查实，立即删除！

分享到：
领支付宝红包 赞助服务器费用

相关文章

  • C++利用开散列哈希表封装unordered_set,unordered_map

    C++利用开散列哈希表封装unordered_set,unordered_map

    1.之前我们已经实现了开散列的哈希表,今天我们来用它封装unordered_set,unordered_map 2.本文的封装比利用红黑树封装set和map更加复杂 建议大家先去看我的红黑树封装set和map再来看本文 因为有很多地方跟红黑树封装set和map时是同样的思路和方法,所以本文不会太去赘述一遍 因为un

    2024年03月24日
    浏览(38)
  • 【C++】开散列哈希表封装实现unordered_map和unordered_set

    【C++】开散列哈希表封装实现unordered_map和unordered_set

    在未达成目的之前，一切具有诱惑力的事物都显得那么不堪一击 1. 在C++98中，STL提供了底层为红黑树结构的一系列关联式容器，在查询时效率可达到 l o g 2 N log_2 N l o g 2 ​ N ，即最差情况下需要比较红黑树的高度次，当树中的节点非常多时，查询效率也不理想。 最好的查询是

    2023年04月09日
    浏览(69)
  • 【C++】如何用一个哈希表同时封装出unordered_set与unordered_map

    【C++】如何用一个哈希表同时封装出unordered_set与unordered_map

    👀 樊梓慕： 个人主页  🎥 个人专栏： 《C语言》 《数据结构》 《蓝桥杯试题》 《LeetCode刷题笔记》 《实训项目》 《C++》 《Linux》 《算法》 🌝 每一个不曾起舞的日子，都是对生命的辜负 目录 前言 1.哈希桶源码  2.哈希表模板参数的控制 3.字符串作为键值如何映射哈希值

    2024年03月26日
    浏览(34)
  • 从C语言到C++_31(unordered_set和unordered_map介绍+哈希桶封装)

    从C语言到C++_31(unordered_set和unordered_map介绍+哈希桶封装)

    目录 1. unordered_set和unordered_map 1.1 unordered_map 1.2 unordered_set 1.3 unordered系列写OJ题 961. 在长度 2N 的数组中找出重复 N 次的元素 - 力扣（LeetCode） 349. 两个数组的交集 - 力扣（LeetCode） 217. 存在重复元素 - 力扣（LeetCode） 884. 两句话中的不常见单词 - 力扣（LeetCode） 2. 实现unorder

    2024年02月13日
    浏览(24)
  • 【C++学习】哈希表的底层实现及其在unordered_set与unordered_map中的封装

    【C++学习】哈希表的底层实现及其在unordered_set与unordered_map中的封装

    🎉个人名片： 🐼作者简介：一名乐于分享在学习道路上收获的大二在校生 🙈个人主页🎉：GOTXX 🐼个人WeChat：ILXOXVJE 🐼本文由GOTXX原创，首发CSDN🎉🎉🎉 🐵系列专栏：零基础学习C语言----- 数据结构的学习之路----C++的学习之路 🐓每日一句：如果没有特别幸运，那就请特

    2024年04月16日
    浏览(33)
  • 【C++】unordered_set 和 unordered_map 使用 | 封装

    【C++】unordered_set 和 unordered_map 使用 | 封装

    unordered_map官方文档 unordered_set 官方文档 set / map与unordered_set / unordered_map 使用功能基本相同，但是两者的底层结构不同 set/map底层是红黑树 unordered_map/unordered_set 底层是 哈希表 红黑树是一种搜索二叉树，搜索二叉树又称为排序二叉树，所以 迭代器遍历是有序的 而哈希表对应的

    2024年02月06日
    浏览(28)
  • C++进阶--使用哈希表实现unordered_map和unordered_set的原理与实例

    C++进阶--使用哈希表实现unordered_map和unordered_set的原理与实例

    本文将介绍如何使用哈希表来实现C++ STL库中的unordered_map和unordered_set容器。我们将会解释哈希表的基本原理，并给出具体的代码示例，帮助读者更好地理解和应用哈希表。 哈希原理讲解–链接入口 set和map的实现的文章，与unordered_map实现类似 unordered_set是一种集合存储的容器

    2024年04月09日
    浏览(33)
  • STL容器——unordered_set的用法

    STL容器——unordered_set的用法

    unordered_set 容器，可直译为 无序 set 容器 。即 unordered_set 容器和 set 容器很像，唯一的区别就在于 set 容器会自行对存储的数据进行排序，而 unordered_set 容器不会。 下面是 set 、 multiset 和 unordered_set 之间的差别。 注意这三种集合的底层实现，他决定了算法的时间复杂度。特别

    2024年02月09日
    浏览(30)

  • 封装unordered_set&&unordered_map

    注：实现unordered系列容器是为了学习，因此并非将全部接口实现，所以只实现部分接口 目录 哈希表的改造 模板参数列表的改造 增加迭代器操作 增加通过T获取value操作 HashTable.h的修改 unordered_set的封装 unordered_map的封装 K：关键码类型 T：不同容器T的类型不同，如果是unorder

    2024年02月05日
    浏览(28)

  • STL之unordered_set 【无序不重复集合】

    unordered_set ：无序集合，与 set 类似，但 不进行排序 ，提供更快的查找操作。 unordered_set是C++标准库中的一个容器，用于存储不重复的元素集合。它是哈希表的一种实现，因此能够提供快速的插入、查找和删除操作。它的特性如下： 有序性：unordered_set中的元素是无序的，也就

    2024年01月24日
    浏览(28)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包，优惠每天领

二维码1

领取红包

二维码2

领红包