devbox
小桥流水78
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

用哈希表封装unordered_map(以及unordered_set)【C++】

作者：小桥流水78 | 2024-08-07 06:12:50

赞

踩

用哈希表封装unordered_map(以及unordered_set)【C++】

目录

一，前言

二，封装层框架（哈希底层以哈希桶为例）

三，迭代器

1. operator++

2. operator[]

3. 仿函数优化

3. 解决unordered_set中Key可以修改的Bug

代码区

Hash_map_set.h

HashTable.h

总结：用红黑树还是哈希表？？

哈希表优势：

缺点：

红黑树优势：

下节预告：哈希应用！！

结语

一，前言

在学习封装unordered_map与unordered_set前，建议先学习如何封装map & set该篇文章用红黑树封装map&set【C++】-CSDN博客

这样更能理解其中的封装思想(两种封装方式，主题思路大体相似)

同时用哈希表封装 unordered_map和undordered_set，在封装之前，我们首先是要学会哈希表基本的精华，哈希实现建议大家先学习从底层认识哈希表【C++】-CSDN博客

二，封装层框架（哈希底层以哈希桶为例）

由于我们前面已经学习过map与set的封装，在学习unordered_map(set) 封装这里我们直接给出基本的框架代码啦！ 

本质上：还是对哈希表进行封装，在unordered_map层面调用哈希底层。

用哈希表封装 unordered_map &  unordered_set，思想核心：就是让unordered_set如何适应unordered_map,看到这里的都是已经学习过红黑树封装map与set的童鞋了吧

  1. namespace hash_map_set
  2. {
  3. 	template <class K>
  4. 	class unordered_set
  5. 	{
  6. 	public:
  7. 		struct SetkeyofT   // 从T类型中提取Key
  8. 		{
  9. 			const K& operator()(const K& key)
  10. 			{
  11. 				return key;
  12. 			}
  13. 		};
  14.  
  15. 		bool insert(const K& data)
  16. 		{
  17. 			return table.insert(data);
  18. 		}
  19.  
  20. 	private:
  21. 		hash_barrel::HashTable<K, K, SetkeyofT>  table;
  22. 	};
  23.  
  24. 	template <class K, class V> 
  25. 	class unordered_map
  26. 	{
  27. 	public:
  28.  
  29. 		struct MapkeyofT
  30. 		{
  31. 			const K& operator()(const pair<const K, V>& kv)
  32. 			{
  33. 				return kv.first;
  34. 			}
  35. 		};
  36.  
  37. 		bool insert(const pair<const K, V>& kv)
  38. 		{
  39. 			return table.insert(kv);
  40. 		}
  41. 	private:
  42. 		hash_barrel::HashTable<K, pair<const K, V>, MapkeyofT>  table;
  43. 	};
  44. }
  45. // 哈希表底层部分变化，为了避免冗余，就只展现部分代码
  46.  
  47. template <class T>
  48. 	struct Node_Data
  49. 	{
  50. 		typedef Node_Data<T> Node_data;
  51. 		T _data;
  52. 		Node_data* _downstars = nullptr;
  53.  
  54. 		Node_Data(const T& pa = T())
  55. 			:_data(pa)
  56. 		{}
  57. 	};
  58.  
  59. template <class K, class T, class KeyofT ,class Hashstr = Hashstr<K>>
  60. 	class HashTable
  61. 	{
  62. 	public:
  63. 		typedef Node_Data<T> Node_Data;
  64.  
  65. .......

三，迭代器

首先我们先完成 迭代器基本框架 和 基本“ * ”， “ & ”，“ ->”, " != "实现，代码其实比较简单，重要的是逻辑如何行云流水的形成，多写多看多思考吧！！

  1.     template <class T>
  2. 	struct Node_Data
  3. 	{
  4. 		typedef Node_Data<T> Node_data;
  5. 		T _data;
  6. 		Node_data* _downstars = nullptr;
  7.  
  8. 		Node_Data(const T& pa = T())
  9. 			:_data(pa)
  10. 		{}
  11. 	};
  12.  
  13. 	template <class type>
  14. 	struct Hashstr
  15. 	{
  16. 		int operator()(const type& sd)
  17. 		{
  18. 			return sd;
  19. 		}
  20. 	};
  21.  
  22. 	template<>
  23. 	struct Hashstr<string>
  24. 	{
  25. 		size_t operator()(const string& str)
  26. 		{
  27. 			size_t sum = 0;
  28. 			for (auto e : str)
  29. 			{
  30. 				sum += e;
  31. 				sum *= 31;   // 别问，问就是实验的结果
  32. 			}
  33. 			return sum;
  34. 		}
  35. 	};
  36.  
  37. 	// 由于迭代器需要使用HashTable作为成员变量，因此需要前置声明
  38. 	template <class K, class T, class KeyofT, class Hashstr = Hashstr<K>>
  39. 	class HashTable;
  40.  
  41. 	template <class K, class T, class KeyofT, class Ref, class Ptr, class Hash>
  42. 	struct HT_iterator
  43. 	{
  44. 		typedef Node_Data<T> Node_Data;
  45. 		typedef HashTable<K, T, KeyofT, Hash> HashTable;
  46. 		typedef HT_iterator<K, T, KeyofT, Ref, Ptr, Hash> HT_iter; // 正常迭代器
  47.  
  48. 		Node_Data* _node;  // 当前位置
  49. 		HashTable* _ht;    // 当前哈希表
  50. 		size_t _bucket = -1;     // 当前桶
  51.  
  52. 		HT_iterator(Node_Data* node, HashTable* ht)
  53. 			:_node(node)
  54. 			, _ht(ht)
  55. 		{
  56. 			Hash hashstr;
  57. 			KeyofT keyofT;
  58. 			if (node) // node为空的时候，我们会对nullptr进行访问，所以规避一下
  59. 			_bucket = hashstr(keyofT(_node->_data)) % _ht->Get_tables().size();
  60. 		}
  61.  
  62. 		// HT_iterator(const HT_iterator)
  63.  
  64. 		Ref operator*()
  65. 		{
  66. 			return _node->_data;
  67. 		}
  68.  
  69. 		Ptr operator->()
  70. 		{
  71. 			return &(_node->_data);
  72. 		}
  73.  
  74. 		bool operator!=(const HT_iter& it)
  75. 		{
  76. 			return _node != it._node;
  77. 		}
  78. 	};

1. operator++

思路：从第一个桶开始访问数据，访问完一个数据后，接着下一个桶，直至结束。

思路比较简单，但迭代器设计，逻辑比较难处理。

  1.  
  2.         // 哈希迭代器只往前单向
  3. 		HT_iter operator++()
  4. 		{
  5. 			// 三种情况：
  6. 			// 1. 下一个为空,下一个桶存在
  7. 			// 2. 下一个为空，下一个不存在
  8. 			// 3. 下一个存在
  9. 			if (_node->_downstars)
  10. 			{ // 3.
  11. 				_node = _node->_downstars;
  12. 				return *this;
  13. 			}
  14. 			else
  15. 			{   // 1 , 2
  16. 				 寻找下一个不为空的桶
  17. 				++_bucket;
  18. 				while (_bucket < _ht->Get_tables().size())
  19. 				{
  20. 					_node = (_ht->Get_tables())[_bucket];
  21. 					if (_node)  // 找到后中断寻找
  22. 						break;
  23. 					++_bucket;
  24. 				}
  25. 				return *this;
  26. 			}
  27. 		}

2. operator[]

在实现operator[]时，我们需要先将insert，find函数进行优化:

让insert返回值从bool ——> 返回pair<iterator,  bool>；

find()从返回数据指针——>  返回迭代器;

  1. // Hashtable——哈希类中
  2.         T& operator[](const T& pa)
  3. 		{
  4. 			pair<HT_iterator, bool> it = insert(pa);
  5. 			return *(it.first);
  6. 		}
  7.  
  8. // 封装层 unordered_map
  9.         V& operator[](const K& pa)
  10. 		{
  11. 			pair<HT_iterator, bool> ret = insert(make_pair(pa, V()));
  12. 			return ret.first->second;
  13. 		}
  14.         
  15. // unordered_set
  16.         K& operator[](const K& pa)
  17. 		{
  18. 			return table[pa];
  19. 		}

3. 仿函数优化

在哈希实现过程中，我们实现了该仿函数，目的就是为了解决当 K不是int的时候(比如string类)无法转化为size_t类型，来寻找哈希地址。 

那么问题来了！！  我如果想将Day类型(处理年，月，日的类)作为K呢？？ 请问这怎么将这个日期类转化为size_t???

为了方便分析，我将这个将其他数据转化为size_t的类叫做转化类 

我们会发现，封装在底层的中转化类（int与string类）在目前看来，应该将其放在unordered_map与unordered_set的封装层；同时在两个封装层添加一个新的参数，作为转化类的行参。

这样做的好处是，在我们不知道K类型时，用户可以导入其自己设定的转化类，来实现各种类(各种类型)转化为size_t类型。

3. 解决unordered_set中Key可以修改的Bug

在前面的文章中（用红黑树封装map&set【C++】-CSDN博客），我们已经修复过一次了，这里就只展现修改位置了。

代码区

Hash_map_set.h

  1. namespace hash_map_set
  2. {
  3.  
  4. 	template <class type>
  5. 	struct Hashstr
  6. 	{
  7. 		int operator()(const type& sd)
  8. 		{
  9. 			return sd;
  10. 		}
  11. 	};
  12.  
  13. 	template<>
  14. 	struct Hashstr<string>
  15. 	{
  16. 		size_t operator()(const string& str)
  17. 		{
  18. 			size_t sum = 0;
  19. 			for (auto e : str)
  20. 			{
  21. 				sum += e;
  22. 				sum *= 31;   // sum为啥都要乘31这个数？？1.减少数据聚集在一个桶中。2.31这个数是大量实验的最佳数
  23. 			}
  24. 			return sum;
  25. 		}
  26. 	};
  27.  
  28. 	template <class K, class Hash = Hashstr<K>>
  29. 	class unordered_set
  30. 	{
  31. 	public:
  32. 		struct SetkeyofT   // 从T类型中提取Key
  33. 		{
  34. 			const K& operator()(const K& key)
  35. 			{
  36. 				return key;
  37. 			}
  38. 		};
  39.  
  40. 		// 关于为什么要这样操作？原因：底层(HT_iterator)实例化后，再取得模板,而不是自己设定
  41. 		typedef typename hash_barrel::HashTable<K, K, SetkeyofT, Hash>::const_HT_iterator  HT_iterator;
  42. 		typedef typename hash_barrel::HashTable<K, K, SetkeyofT, Hash>::const_HT_iterator const_HT_iterator;
  43.  
  44. 		const_HT_iterator begin() const
  45. 		{
  46. 			return table.begin();
  47. 		}
  48.  
  49. 		const_HT_iterator end() const 
  50. 		{
  51. 			return table.end();
  52. 		}
  53.  
  54. 		HT_iterator begin()
  55. 		{
  56. 			return table.begin();
  57. 		}
  58.  
  59. 		HT_iterator end()
  60. 		{
  61. 			return table.end();
  62. 		}
  63.  
  64. 		pair<HT_iterator, bool> insert(const K& data)
  65. 		{
  66. 			return table.insert(data);
  67. 		}
  68.  
  69. 		K& operator[](const K& pa)
  70. 		{
  71. 			return table[pa];
  72. 		}
  73.  
  74. 		HT_iterator find(const K& pa)
  75. 		{
  76. 			return table.find(pa);
  77. 		}
  78.  
  79. 		bool erase(const K& pa)
  80. 		{
  81. 			return table.erase(pa);
  82. 		}
  83.  
  84. 	private:
  85. 		hash_barrel::HashTable<K, K, SetkeyofT, Hash>  table;
  86. 	};
  87.  
  88. 	template <class K, class V, class Hash = Hashstr<K>> 
  89. 	class unordered_map
  90. 	{
  91. 	public:
  92.  
  93. 		struct MapkeyofT
  94. 		{
  95. 			const K& operator()(const pair<const K, V>& kv)
  96. 			{
  97. 				return kv.first;
  98. 			}
  99. 		};
  100.  
  101. 		typedef typename hash_barrel::HashTable<K, pair<const K, V>, MapkeyofT, Hash>::HT_iterator  HT_iterator;
  102. 		typedef typename hash_barrel::HashTable<K, pair<const K, V>, MapkeyofT, Hash>::const_HT_iterator  const_HT_iterator;
  103.  
  104. 		const_HT_iterator begin() const 
  105. 		{
  106. 			return table.begin();
  107. 		}
  108.  
  109. 		const_HT_iterator end() const 
  110. 		{
  111. 			return table.end();
  112. 		}
  113.  
  114. 		HT_iterator begin()
  115. 		{
  116. 			return table.begin();
  117. 		}
  118.  
  119. 		HT_iterator end()
  120. 		{
  121. 			return table.end();
  122. 		}
  123.  
  124. 		pair<HT_iterator, bool> insert(const pair<const K, V>& kv)
  125. 		{
  126. 			return table.insert(kv);
  127. 		}
  128.  
  129. 		V& operator[](const K& pa)
  130. 		{
  131. 			pair<HT_iterator, bool> ret = insert(make_pair(pa, V()));
  132. 			return ret.first->second;
  133. 		}
  134.  
  135. 		HT_iterator find(const K& pa)
  136. 		{
  137. 			return table.find(pa);
  138. 		}
  139.  
  140. 		bool erase(const K& pa)
  141. 		{
  142. 			return table.erase(pa);
  143. 		}
  144.  
  145. 	private:
  146. 		hash_barrel::HashTable<K, pair<const K, V>, MapkeyofT, Hash>  table;
  147. 	};
  148. }

HashTable.h

  1. namespace hash_barrel
  2. {
  3. 	template <class T>
  4. 	struct Node_Data
  5. 	{
  6. 		typedef Node_Data<T> Node_data;
  7. 		T _data;
  8. 		Node_data* _downstars = nullptr;
  9.  
  10. 		Node_Data(const T& pa = T())
  11. 			:_data(pa)
  12. 		{}
  13. 	};
  14.  
  15. 	// 由于迭代器需要使用HashTable作为成员变量，因此需要前置声明
  16. 	template <class K, class T, class KeyofT, class Hashstr>
  17. 	class HashTable;
  18.  
  19. 	template <class K, class T, class KeyofT, class Ref, class Ptr, class Hash>
  20. 	struct HT_iterator
  21. 	{
  22. 		typedef Node_Data<T> Node_Data;
  23. 		typedef HashTable<K, T, KeyofT, Hash> HashTable;
  24. 		typedef HT_iterator<K, T, KeyofT, Ref, Ptr, Hash> HT_iter; // 正常迭代器
  25. 		typedef HT_iterator<K, T, KeyofT, T&, T*, Hash> iterator; 
  26.  
  27. 		Node_Data* _node;  // 当前位置
  28. 		const HashTable* _ht;    // 当前哈希表,添加const原因:1.迭代器不会修改哈希表 2.const迭代器传入的是const的哈希表,所以需要适配
  29. 		size_t _bucket = -1;     // 当前桶
  30.  
  31. 		HT_iterator(Node_Data* node, const HashTable* ht)
  32. 			:_node(node)
  33. 			, _ht(ht)
  34. 		{
  35. 			Hash hashstr;
  36. 			KeyofT keyofT;
  37. 			if (node) // node为空的时候，我们会对nullptr进行访问，所以规避一下
  38. 				_bucket = hashstr(keyofT(_node->_data)) % _ht->Get_tables().size();
  39. 		}
  40.  
  41. 		// 1. 当对象是普通迭代器时，这是拷贝构造
  42. 		// 2. 当对象是const迭代器时，是利用普通迭代器构造const迭代器的构造函数
  43. 		HT_iterator(const iterator& it)
  44. 			:_node(it._node)
  45. 			,_ht(it._ht)
  46. 			,_bucket(it._bucket)
  47. 		{}
  48.  
  49. 		// HT_iterator(const HT_iterator)
  50.  
  51. 		Ref operator*()
  52. 		{
  53. 			return _node->_data;
  54. 		}
  55.  
  56. 		Ptr operator->()
  57. 		{
  58. 			return &(_node->_data);
  59. 		}
  60.  
  61. 		bool operator!=(const HT_iter& it)
  62. 		{
  63. 			return _node != it._node;
  64. 		}
  65.  
  66. 		// 哈希迭代器只往前单向
  67. 		HT_iter operator++()
  68. 		{
  69. 			// 三种情况：
  70. 			// 1. 下一个为空,下一个桶存在
  71. 			// 2. 下一个为空，下一个不存在
  72. 			// 3. 下一个存在
  73. 			if (_node->_downstars)
  74. 			{ // 3.
  75. 				_node = _node->_downstars;
  76. 				return *this;
  77. 			}
  78. 			else
  79. 			{   // 1 , 2
  80. 				 寻找下一个不为空的桶
  81. 				++_bucket;
  82. 				while (_bucket < _ht->Get_tables().size())
  83. 				{
  84. 					_node = (_ht->Get_tables())[_bucket];
  85. 					if (_node)
  86. 						break;
  87. 					++_bucket;
  88. 				}
  89. 				return *this;
  90. 			}
  91. 		}
  92. 	};
  93.  
  94.  
  95.  
  96. 	template <class K, class T, class KeyofT ,class Hash>
  97. 	class HashTable
  98. 	{
  99. 	public:
  100. 		typedef Node_Data<T> Node_Data;
  101. 		typedef HT_iterator<K, T, KeyofT, const T&, const T*, Hash>  const_HT_iterator;  // const迭代器
  102. 		typedef HT_iterator<K, T, KeyofT, T&, T*, Hash> HT_iterator;    // 普通迭代器
  103. 		
  104. 		~HashTable()
  105. 		{
  106. 			for (auto bucket : _tables)
  107. 			{
  108. 				Node_Data* cur = bucket;
  109. 				while (cur)
  110. 				{
  111. 					Node_Data* next = cur->_downstars;
  112. 					delete (cur);
  113. 					cur = next;
  114. 				}
  115. 			}
  116. 		}
  117.  
  118. 		const_HT_iterator begin() const 
  119. 		{
  120. 			size_t i = 0;
  121. 			Node_Data* cur = nullptr;
  122. 			for (; i < _tables.size(); i++)
  123. 			{
  124. 				cur = _tables[i];
  125.  
  126. 				if (cur)
  127. 					break;
  128. 			}
  129.  
  130. 			return const_HT_iterator(cur, this);  // this就是哈希表对象
  131. 		}
  132.  
  133. 		const_HT_iterator end() const 
  134. 		{
  135. 			return const_HT_iterator(nullptr, this);
  136. 		}
  137.  
  138. 		HT_iterator begin()
  139. 		{
  140. 			size_t i = 0;
  141. 			Node_Data* cur = nullptr;
  142. 			for (; i < _tables.size(); i++)
  143. 			{
  144. 				cur = _tables[i];
  145.  
  146. 				if (cur)
  147. 					break;
  148. 			}
  149. 			return HT_iterator(cur, this);  // this就是哈希表对象
  150. 		}
  151.  
  152. 		HT_iterator end()
  153. 		{
  154. 			return HT_iterator(nullptr, this);
  155. 		}
  156.  
  157. 		// 在实现 operator[]时，底层用到insert(),没找到，插入新值返回迭代器；找到直接返回迭代器
  158. 		pair<HT_iterator,bool> insert(const T& pa)
  159. 		{
  160. 			KeyofT keyofT;
  161. 			HT_iterator ret = _find(keyofT(pa));
  162. 			if (ret != end())
  163. 				return make_pair(ret, true);  
  164.  
  165. 			// 考虑扩容：负载因子为1，2，3都可以
  166. 			Hash hashstr;
  167. 			if (_tables.size() == 0 || _n * 10 / _tables.size() >= 10)
  168. 			{
  169. 				size_t  new_size = _tables.size() == 0 ? 10 : _tables.size() * 2;
  170. 			     // 开始扩容	
  171. 				vector<Node_Data*> new_tables;
  172. 				new_tables.resize(new_size);
  173. 				for (auto& data : _tables)
  174. 				{
  175. 					// 处理桶内的数据，重新插入新节点
  176. 					Node_Data* cur = data;
  177. 					while (cur)
  178. 					{
  179. 						Node_Data* room = cur->_downstars;
  180. 						size_t new_hashi = hashstr(keyofT(cur->_data)) % new_tables.size();
  181. 						// 处理结点关系
  182. 						Node_Data* tmp = new_tables[new_hashi];
  183. 						new_tables[new_hashi] = cur;
  184. 						cur->_downstars = tmp;
  185. 						cur = room;
  186. 					}
  187. 				}
  188. 				_tables.swap(new_tables);
  189. 			}
  190.  
  191. 			size_t hashi = hashstr(keyofT(pa)) % _tables.size();
  192. 			Node_Data* new_node = new Node_Data(pa);
  193. 			new_node->_downstars = _tables[hashi];
  194. 			_tables[hashi] = new_node;
  195. 			_n++;
  196. 			return make_pair(HT_iterator(new_node, this), true);
  197. 		}
  198.  
  199. 		HT_iterator find(const K& order)
  200. 		{
  201. 			return _find(order);
  202. 		}
  203.  
  204. 		bool erase(const K& order)
  205. 		{
  206. 			Hash hashstr;
  207. 			HT_iterator cur = find(order);
  208. 			if (!(cur._node))
  209. 			{
  210. 				cout << "擦除失败: 不存在" << endl;
  211. 				return false;
  212. 			}
  213. 			size_t index = hashstr(order) % _tables.size();
  214. 			Node_Data* tmp = _tables[index];
  215.  
  216. 			while (tmp)
  217. 			{
  218. 				if (cur._node == tmp)
  219. 				{
  220. 					break;
  221. 				}
  222. 				else if (cur._node == tmp->_downstars)
  223. 				{
  224. 					break;
  225. 				}
  226. 				tmp = tmp->_downstars;
  227. 			}
  228. 			// 开始处理节点
  229. 			if (tmp == _tables[index])  // 如果擦除的是头,那要置空的包括指针数组
  230. 			{
  231. 				_tables[index] = cur._node->_downstars;
  232. 			}
  233. 			else
  234. 			{
  235. 				tmp->_downstars = cur._node->_downstars;
  236. 			}
  237. 			
  238. 			delete (cur._node);
  239. 			cout << "擦除成功" << endl;
  240. 			return true;
  241. 		}
  242.  
  243. 		T& operator[](const T& pa)
  244. 		{
  245. 			pair<HT_iterator, bool> it = insert(pa);
  246. 			return *(it.first);
  247. 		}
  248.  
  249. 		size_t Get_n()
  250. 		{return _n; }
  251.  
  252. 		 vector<Node_Data*>& Get_tables()
  253. 		{
  254. 			return _tables;
  255. 		}
  256.  
  257. 		 // 需要为const 对象进行重载
  258. 		 const vector<Node_Data*>& Get_tables() const 
  259. 		 {
  260. 			 return _tables;
  261. 		 }
  262.  
  263. 	private:
  264. 		// Node_Data* _find(const K& order)
  265. 		HT_iterator _find(const K& order)
  266. 		{
  267. 			if (!_tables.size())
  268. 				return end();
  269.  
  270. 			Hash hashstr;
  271. 			KeyofT keyofT;
  272. 			size_t hashi = hashstr(order) % _tables.size();
  273. 			auto cur = _tables[hashi];
  274. 			while (cur)
  275. 			{
  276. 				if (keyofT(cur->_data) == order)
  277. 					return HT_iterator(cur, this);
  278. 				cur = cur->_downstars;
  279. 			}
  280. 			return end();
  281. 		}
  282.  
  283. 		vector<Node_Data*> _tables;  // 存放各个哈希地址的第一个结点地址的指针数组
  284. 		size_t _n = 0;                  // 哈希桶中，数据个数
  285. 	};
  286. }

总结：用红黑树还是哈希表？？

哈希表优势：

哈希表的查找，插入，删除操作平均为O(1)；红黑树的查找，插入，删除平均O(logn)。因此哈希表会有更高的效率。

缺点：

1. 哈希表存在，哈希冲突，而解决方案有 哈希桶法(链表法),开放定址法。如果超过负载值，将对全部数据进行重新分配，这会导致性能下降。

2. 占用更多的内存

红黑树优势：

1. 相比于哈希表红黑树占用内存比较少。

2. 相比于哈希表插入可能需要重新分配哈希桶，红黑树的插入效率不差，也更稳定。

因此：选择哈希表还是红黑树作为map的底层数据结构取决于具体的应用场景。如果对性能要求较高且不需要有序性，可以选择哈希表。如果需要有序性或者对性能要求不是特别高，可以选择红黑树。

 

下节预告：哈希应用！！

结语

   本小节就到这里了，感谢小伙伴的浏览，如果有什么建议，欢迎在评论区评论，如果给小伙伴带来一些收获请留下你的小赞，你的点赞和关注将会成为博主创作的动力。

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/小桥流水78/article/detail/941272
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号