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

＜unordered_set、unordered_map的模拟实现＞——《C++高阶》_c++unodered_map手动实现

作者：小丑西瓜9 | 2024-04-19 14:44:27

赞

踩

c++unodered_map手动实现

目录

 1.unordered_set、unordered_map的结构分析:

1.1 哈希表的改造

1.2 unordered_map模型分析：

2.unordered_set、unordered_map模拟实现：

2.1 unordered_set模拟实现:

2.2 unordered_map模拟实现:

2.3 附用的模拟实现的开散列哈希表

后记：●由于作者水平有限，文章难免存在谬误之处，敬请读者斧正，俚语成篇，恳望指教！

                                                                           ——By 作者：新晓·故知

 1.unordered_set、unordered_map的结构分析:

1.1 哈希表的改造

1. 模板参数列表的改造 
  1. // K:关键码类型
  2. // V: 不同容器V的类型不同，如果是unordered_map，V代表一个键值对，如果是
  3. unordered_set,V 为 K
  4. // KeyOfValue: 因为V的类型不同，通过value取key的方式就不同，详细见
  5. unordered_map/set的实现
  6. // HF: 哈希函数仿函数对象类型，哈希函数使用除留余数法，需要将Key转换为整形数字才能
  7. 取模
  8. template<class K, class V, class KeyOfValue, class HF = DefHashF<T> >
  9. class HashBucket;
2. 增加迭代器操作 
  1. // 为了实现简单，在哈希桶的迭代器类中需要用到hashBucket本身，
  2. template<class K, class V, class KeyOfValue, class HF>
  3. class HashBucket;
  4. // 注意：因为哈希桶在底层是单链表结构，所以哈希桶的迭代器不需要--操作
  5. template <class K, class V, class KeyOfValue, class HF>
  6. struct HBIterator
  7. {
  8.  typedef HashBucket<K, V, KeyOfValue, HF> HashBucket;
  9.  typedef HashBucketNode<V>* PNode;
  10.  typedef HBIterator<K, V, KeyOfValue, HF> Self;
  11.  HBIterator(PNode pNode = nullptr, HashBucket* pHt = nullptr);
  12.  Self& operator++()
  13.  {
  14.          // 当前迭代器所指节点后还有节点时直接取其下一个节点
  15.  if (_pNode->_pNext)
  16.  _pNode = _pNode->_pNext;
  17.  else
  18.  {
  19.  // 找下一个不空的桶，返回该桶中第一个节点
  20.  size_t bucketNo = _pHt->HashFunc(KeyOfValue()(_pNode- >_data))+1;
  21.  for (; bucketNo < _pHt->BucketCount(); ++bucketNo)
  22.  {
  23.  if (_pNode = _pHt->_ht[bucketNo])
  24.  break;
  25.  }
  26.  }return *this;
  27.  }
  28.  Self operator++(int);
  29.     V& operator*();
  30.  V* operator->();
  31.  bool operator==(const Self& it) const;
  32.  bool operator!=(const Self& it) const;
  33.  PNode _pNode;             // 当前迭代器关联的节点
  34.  HashBucket* _pHt;         // 哈希桶--主要是为了找下一个空桶时候方便
  35. };
3. 增加通过key获取value操作 
  1. template<class K, class V, class KeyOfValue, class HF = DefHashF<T> >
  2. class HashBucket
  3. {
  4.  friend HBIterator<K, V, KeyOfValue, HF>;
  5.     // ......
  6. public:
  7.  typedef HBIterator<K, V, KeyOfValue, HF> Iterator;
  8.  //
  9.     // ...
  10.  // 迭代器
  11.  Iterator Begin()
  12.  {
  13.  size_t bucketNo = 0;
  14.  for (; bucketNo < _ht.capacity(); ++bucketNo)
  15.  {
  16.  if (_ht[bucketNo])
  17.  break;
  18.  }
  19.  if (bucketNo < _ht.capacity())
  20.  return Iterator(_ht[bucketNo], this);
  21.  else
  22.  return Iterator(nullptr, this);
  23.  }
  24.  Iterator End(){ return Iterator(nullptr, this);}
  25.     Iterator Find(const K& key);
  26.  Iterator Insert(const V& data);
  27.  Iterator Erase(const K& key);
  28.     
  29.     // 为key的元素在桶中的个数
  30.  size_t Count(const K& key)
  31.  {
  32.  if(Find(key) != End())
  33.             return 1;
  34.         
  35.         return 0;
  36.  }
  37.     
  38.     size_t BucketCount()const{ return _ht.capacity();}
  39.     size_t BucketSize(size_t bucketNo)
  40.    {
  41.         size_t count = 0;
  42.    PNode pCur = _ht[bucketNo];
  43.         while(pCur)
  44.        {
  45.             count++;
  46.             pCur = pCur->_pNext;
  47.        }
  48.         
  49.         return count;
  50.    }
  51.     
  52.     // ......
  53. };

1.2 unordered_map模型分析：

  1. // unordered_map中存储的是pair<K, V>的键值对，K为key的类型，V为value的类型，HF哈希
  2. 函数类型
  3. // unordered_map在实现时，只需将hashbucket中的接口重新封装即可
  4. template<class K, class V, class HF = DefHashF<K>>
  5. class unordered_map
  6. {
  7.  typedef pair<K, V> ValueType;
  8. typedef HashBucket<K, ValueType, KeyOfValue, HF> HT;
  9. // 通过key获取value的操作
  10.  struct KeyOfValue
  11.  {
  12.  const K& operator()(const ValueType& data)
  13.  { return data.first;}
  14.  };
  15. public:
  16.  typename typedef HT::Iterator iterator;
  17. public:
  18.  unordered_map(): _ht()
  19.  {}
  20.  
  21.  iterator begin(){ return _ht.Begin();}
  22.  iterator end(){ return _ht.End();}
  23.  
  24.  // capacity
  25.  size_t size()const{ return _ht.Size();}
  26.  bool empty()const{return _ht.Empty();}
  27.  ///
  28.  // Acess
  29.  V& operator[](const K& key)
  30.  {
  31.  return (*(_ht.InsertUnique(ValueType(key, V())).first)).second;
  32.  }
  33.  const V& operator[](const K& key)const;
  34.  //
  35.  // lookup
  36.  iterator find(const K& key){ return _ht.Find(key);}
  37.  size_t count(const K& key){ return _ht.Count(key);}
  38.  /
  39.  // modify
  40.  pair<iterator, bool> insert(const ValueType& valye)
  41.  { return _ht.Insert(valye);}
  42.  iterator erase(iterator position)
  43.  { return _ht.Erase(position);}
  44.  
  45.  // bucket
  46.  size_t bucket_count(){ return _ht.BucketCount();}
  47.  size_t bucket_size(const K& key){ return _ht.BucketSize(key);}
  48. private:
  49.  HT _ht;
  50. };

2.unordered_set、unordered_map模拟实现：

2.1 unordered_set模拟实现:

  1. #include"OpenHT.h"
  2.  
  3. namespace my
  4. {
  5. 	template<class K, class HashFunc = DefaultHash<K>>
  6. 	class unordered_set
  7. 	{
  8. 		//内部类
  9. 		struct SetKeyOfT
  10. 		{
  11. 			const K& operator()(const K& key)
  12. 			{
  13. 				return key;
  14. 			}
  15. 		};
  16. 	public:
  17. 		typedef typename Bucket::HashTable<K, K, SetKeyOfT, HashFunc>::iterator iterator;
  18.  
  19. 		iterator begin()
  20. 		{
  21. 			return _ht.begin();
  22. 		}
  23.  
  24. 		iterator end()
  25. 		{
  26. 			return _ht.end();
  27. 		}
  28. 		//bool insert(const K& key)
  29. 		pair<iterator, bool> insert(const K& key)
  30. 		{
  31. 			return _ht.Insert(key);
  32. 		}
  33. 		iterator find(const K& key)
  34. 		{
  35. 			return _ht.Find(key);
  36. 		}
  37. 		bool erase(const K& key)
  38. 		{
  39. 			return _ht.Erase(key);
  40. 		}
  41. 	private:
  42. 		Bucket::HashTable<K, K, SetKeyOfT,HashFunc> _ht;
  43. 	};
  44. 	
  45. }

 2.2 unordered_map模拟实现:

 

  1. #include"OpenHT.h"
  2.  
  3. namespace my
  4. {
  5. 	template<class K, class V, class HashFunc = DefaultHash<K>>
  6. 	class unordered_map
  7. 	{
  8. 		//内部类
  9. 		struct MapKeyOfT
  10. 		{
  11. 			const K& operator()(const pair<K,V>& kv)
  12. 			{
  13. 				return kv.first;
  14. 			}
  15. 		};
  16. 	public:
  17. 		//定义map的迭代器
  18. 		typedef typename Bucket::HashTable<K, pair<K, V>, MapKeyOfT, HashFunc> ::iterator iterator;
  19. 		iterator begin()
  20. 		{
  21. 			return _ht.begin();
  22. 		}
  23.  
  24. 		iterator end()
  25. 		{
  26. 			return _ht.end();
  27. 		}
  28. 		//bool insert(const pair<K, V>& kv)
  29. 		pair<iterator,bool> insert(const pair<K, V>& kv)
  30. 		{
  31. 			return _ht.Insert(kv);
  32.  
  33. 		}
  34. 		iterator find(const K& key)
  35. 		{
  36. 			return _ht.Find(key);
  37. 		}
  38. 		bool erase(const K& key)
  39. 		{
  40. 			return _ht.Erase(key);
  41. 		}
  42. 		V& operator[](const K& key)
  43. 		{
  44. 			//pair<iterator, bool> ret = insert(make_pair(key, V()));
  45. 			auto ret = insert(make_pair(key, V()));
  46. 			return ret.first->second;  //first是迭代器，而map里面访问second要用->,其实这里有两个->,但为了可读性
  47. 		}
  48. 	private:
  49. 		Bucket::HashTable<K, pair<K, V>, MapKeyOfT,HashFunc> _ht;
  50. 	};
  51. }

2.3 附用的模拟实现的开散列哈希表

OpenHT.h:

  1. #pragma once
  2. #include<iostream>
  3. #include<string>
  4. #include<vector>
  5. #include<map>
  6. #include<set>
  7. #include<unordered_map>
  8. #include<unordered_set>
  9. using namespace std;
  10.  
  11. //仿函数
  12. template<class K>
  13. struct DefaultHash        //1.普通类直接强转
  14. {
  15. 	size_t operator()(const K& key)
  16. 	{
  17. 		return(size_t)key; //支持取模，强转为整数
  18. 	}
  19. };
  20. template<>
  21. struct DefaultHash<string>     //String类特化
  22. {
  23. 	size_t operator()(const string& key)
  24. 	{
  25. 		//4.BKDR法
  26. 		size_t hash = 0;
  27. 		for (auto ch : key)
  28. 		{
  29. 			hash = hash * 131 + ch;
  30. 		}
  31. 		return hash;
  32. 	}
  33. };
  34. namespace Bucket
  35. {
  36. 	template<class T>
  37. 	struct HashNode
  38. 	{
  39. 		T _data;
  40. 		HashNode<T>* _next;
  41. 		HashNode(const T& data)
  42. 			:_data(data)
  43. 			, _next(nullptr)
  44. 		{}
  45. 	};
  46.  
  47. 	template<class K, class T, class KeyOfT, class HashFunc>
  48. 	class HashTable;
  49.  
  50. 	template<class K, class T, class KeyOfT, class HashFunc>
  51. 	class __HTIterator   //单向迭代器
  52. 	{
  53. 		typedef HashNode<T> Node;
  54. 		typedef __HTIterator<K, T, KeyOfT, HashFunc> Self;
  55. 	public:
  56. 		Node* _node;
  57. 		HashTable<K, T, KeyOfT, HashFunc>* _pht;
  58. 		__HTIterator(){}   //默认哈希迭代器构造函数
  59. 		__HTIterator(Node* node, HashTable<K, T, KeyOfT, HashFunc>* pht)
  60. 			:_node(node)
  61. 			,_pht(pht)
  62. 		{}
  63.  
  64. 		Self& operator++()
  65. 		{
  66. 			if (_node->_next)
  67. 			{
  68. 				_node = _node->_next;
  69. 			}
  70. 			else
  71. 			{
  72. 				KeyOfT kot;
  73. 				HashFunc hf;
  74. 				size_t hashi = hf(kot(_node->_data))%_pht->_tables.size();
  75. 				++hashi;
  76. 				//找下一个不为空的桶
  77. 				for (; hashi < _pht->_tables.size(); ++hashi)
  78. 				{
  79. 					if (_pht->_tables[hashi])
  80. 					{
  81. 						_node = _pht->_tables[hashi];
  82. 						break;
  83. 					}
  84. 				}
  85.  
  86. 				// 没有找到不为空的桶，用nullptr去做end标识
  87. 				if (hashi == _pht->_tables.size())
  88. 				{
  89. 					_node = nullptr;
  90. 				}
  91. 			}
  92.  
  93. 			return *this;
  94. 		}
  95.  
  96. 		T& operator*()
  97. 		{
  98. 			return _node->_data;
  99. 		}
  100.  
  101. 		T* operator->()
  102. 		{
  103. 			return &_node->_data;
  104. 		}
  105.  
  106. 		bool operator!=(const Self& s) const
  107. 		{
  108. 			return _node != s._node;
  109. 		}
  110.  
  111. 		bool operator==(const Self& s) const
  112. 		{
  113. 			return _node == s._node;
  114. 		}
  115. 	};
  116.  
  117. 	//unordered_set--->HashTable<K, K, SetKeyOfT> _ht;
  118. 	//unordered_map--->HashTable<K, pair<K, V>, MapKeyOfT> _ht;
  119. 	template<class K, class T, class KeyOfT, class HashFunc>
  120. 	class HashTable
  121. 	{
  122. 		template<class K, class T, class KeyOfT, class HashFunc>
  123. 		friend class __HTIterator;
  124. 		typedef HashNode<T> Node;
  125. 	public:
  126. 		typedef __HTIterator<K, T, KeyOfT, HashFunc> iterator;
  127. 		iterator begin()
  128. 		{
  129. 			for (size_t i = 0; i < _tables.size(); ++i)
  130. 			{
  131. 				Node* cur = _tables[i];
  132. 				if (cur)
  133. 				{
  134. 					return iterator(cur, this);
  135. 				}
  136. 			}
  137.  
  138. 			return end();
  139. 		}
  140.  
  141. 		iterator end()
  142. 		{
  143. 			return iterator(nullptr, this);
  144. 		}
  145. 		//手动实现Node的析构函数
  146. 		~HashTable()
  147. 		{
  148. 			for (size_t i = 0; i < _tables.size(); ++i)
  149. 			{
  150. 				Node* cur = _tables[i];
  151. 				while (cur)
  152. 				{
  153. 					Node* next = cur->_next;
  154. 					delete cur;
  155. 					cur = next;
  156. 				}
  157. 				_tables[i] = nullptr;
  158. 			}
  159. 		}
  160. 		
  161. 		///
  162. 		HashTable() = default;  //强制生成默认构造函数
  163.  
  164. 		链表桶的深拷贝
  165. 		//HashTable(const HashTable<K, V> ht)
  166. 		//{
  167. 		//	int sz = ht._tables.size();
  168. 		//	for (int i = 0; i < sz; i++)
  169. 		//	{
  170. 		//		Node* cur = ht._tables[i];
  171. 		//		while (cur)
  172. 		//		{
  173. 		//			this->Insert(cur->_kv);
  174. 		//			cur = cur->_next;
  175. 		//		}
  176. 		//	}
  177. 		//	_n = ht._n;
  178.  
  179. 		//}
  180. 		链表桶的赋值重载
  181. 		//HashTable<K, V>& operator=(HashTable<K, V> ht)
  182. 		//{
  183. 		//	//现代写法
  184. 		//	ht._tablle.swap(_tables);
  185. 		//	_n = ht._n;
  186. 		//}
  187. 		///
  188. 		size_t GetNextPrime(size_t prime)
  189. 		{
  190. 			const int PRIMECOUNT = 28;
  191. 			static const size_t primeList[PRIMECOUNT] =
  192. 			{
  193. 				53ul, 97ul, 193ul, 389ul, 769ul,
  194. 				1543ul, 3079ul, 6151ul, 12289ul, 24593ul,
  195. 				49157ul, 98317ul, 196613ul, 393241ul, 786433ul,
  196. 				1572869ul, 3145739ul, 6291469ul, 12582917ul, 25165843ul,
  197. 				50331653ul, 100663319ul, 201326611ul, 402653189ul, 805306457ul,
  198. 				1610612741ul, 3221225473ul, 4294967291ul
  199. 			};
  200.  
  201. 			// 获取比prime大那一个素数
  202. 			size_t i = 0;
  203. 			for (; i < PRIMECOUNT; ++i)
  204. 			{
  205. 				if (primeList[i] > prime)
  206. 					return primeList[i];
  207. 			}
  208.  
  209. 			return primeList[i];
  210. 		}
  211. 		//bool Insert(const T& data)
  212. 		pair<iterator,bool> Insert(const T& data)
  213. 		{
  214. 			HashFunc hf;
  215. 			KeyOfT kot;
  216. 			//if (Find(kot(data)))  //使用仿函数，不知道data是set还是map
  217. 			//if (Find(kot(data))!=end())  //使用仿函数，不知道data是set还是map
  218.  
  219. 			iterator pos = Find(kot(data));
  220. 			if(pos!=end())
  221. 			{
  222. 				//return false;
  223. 				return make_pair(pos,false);
  224. 			}
  225.  
  226. 			//负载因子（这里设置为1）  扩容
  227. 			if (_tables.size() == _n)
  228. 			{
  229. 				//写法2：扩容
  230. 				//size_t newSize = _tables.size() == 0 ? 10 : _tables.size() * 2;
  231. 				//写法3：
  232. 				size_t newSize = GetNextPrime(_tables.size());
  233. 				if (newSize != _tables.size())
  234. 				{
  235. 					vector<Node*> newTable;
  236. 					newTable.resize(newSize, nullptr);
  237.  
  238. 					for (size_t i = 0; i < _tables.size(); ++i)
  239. 					{
  240. 						Node* cur = _tables[i];
  241. 						while (cur)
  242. 						{
  243. 							size_t hashi = hf(kot(cur->_data)) % newSize;  //hf转换为整型,kot()取k
  244. 							cur->_next = newTable[hashi];
  245. 							newTable[hashi] = cur;
  246. 							cur = cur->_next;
  247. 						}
  248. 						_tables[i] = nullptr;
  249. 					}
  250. 					newTable.swap(_tables);
  251.  
  252. 				}
  253. 			}
  254. 			size_t hashi = hf(kot(data)); //两层仿函数调用
  255. 			hashi %= _tables.size();
  256. 			//头插到对应的桶即可
  257. 			Node* newnode = new Node(data);
  258. 			newnode->_next = _tables[hashi];
  259. 			_tables[hashi] = newnode;
  260. 			++_n;
  261. 			//return true;
  262. 			return make_pair(iterator(newnode,this),false);
  263. 		}
  264. 		//Node* Find(const K& key)
  265. 		iterator Find(const K& key)
  266. 		{
  267. 			if (_tables.size() == 0)
  268. 			{
  269. 				//return nullptr;
  270. 				return iterator(nullptr,this);
  271.  
  272. 			}
  273. 			
  274. 			KeyOfT kot;
  275. 			//写法1：有名对象
  276. 			HashFunc hf;
  277. 			size_t hashi = hf(key);
  278.  
  279. 			//写法2：匿名对象
  280. 			//size_t hashi = HashFunc()(key);
  281.  
  282. 			hashi %= _tables.size();
  283. 			Node* cur = _tables[hashi];
  284. 			while (cur)
  285. 			{
  286. 				if (kot(cur->_data) == key)
  287. 				{
  288. 					//return cur;
  289. 					return iterator(cur, this);
  290. 				}
  291. 				cur = cur->_next;
  292. 			}
  293. 			//return nullptr;  //效率高，是因为直接返回了指针
  294. 			return iterator(nullptr, this);
  295. 		}
  296. 		bool Erase(const K& key)
  297. 		{
  298. 			if (_tables.size() == 0)
  299. 			{
  300. 				return false;
  301. 			}
  302. 			KeyOfT kot;
  303.  
  304. 			//写法1：有名对象
  305. 			HashFunc hf;
  306. 			size_t hashi = hf(key);
  307. 			hashi %= _tables.size();
  308. 			Node* cur = _tables[hashi];
  309. 			Node* prev = nullptr;
  310. 			while (cur)
  311. 			{
  312. 				if (kot(cur->_data) == key)
  313. 				{
  314. 					if (prev == nullptr)
  315. 					{
  316. 						_tables[hashi] = cur->_next;
  317. 					}
  318. 					else
  319. 					{
  320. 						prev->_next = cur->_next;
  321. 					}
  322. 					delete cur;
  323. 					return true;
  324. 					
  325. 				}
  326. 				cur = cur->_next;
  327. 			}
  328. 			return false;
  329. 		}
  330. 	private:
  331. 		//指针数组
  332. 		//没有使用list，是因为list是双向链表，成本大 vector<list<>> _tables; 但不用手动写析构函数
  333. 		vector<Node*> _tables;    
  334. 		//开散列采用挂起，如果新表扩容，那么当旧表释放，vector会将自己的释放，
  335. 		//但是挂在vector的结点Node* 不会自动释放，因为Node* 是内置类型，需要手动释放。
  336. 		size_t _n = 0;
  337. 	};
  338. }

Test.cpp: 

  1. #include"OpenHT.h"
  2. #include"UnorderedSet.h"
  3. #include"UnorderedMap.h"
  4.  
  5. //
  6. //1.库中的UnorderedSet、UnorderedMap测试
  7. void test_std_UnorderedSet()
  8. {
  9. 	std::unordered_set<int> s;
  10. 	s.insert(9);
  11. 	s.insert(7);
  12. 	s.insert(2);
  13. 	s.insert(1);
  14. 	s.insert(6);
  15. 	s.insert(5);
  16. 	//1.迭代器遍历
  17. 	//unordered_set<int>::iterator it = s.begin();
  18. 	//auto it = s.begin();
  19. 	//写法2：
  20. 	std::unordered_set<int>::iterator it;
  21. 	it = s.begin();
  22. 	while (it != s.end())
  23. 	{
  24. 		cout << *it << " ";
  25. 		++it;
  26. 	}
  27. 	cout << endl;
  28. 	//2.范围for遍历
  29. 	for (auto e : s)
  30. 	{
  31. 		cout << e << " ";
  32. 	}
  33. 	cout << endl;
  34. }
  35. void test_std_UnorderedMap()
  36. {
  37. 	std::unordered_map<string, string> dict;
  38. 	dict.insert(make_pair("sort", "排序"));
  39. 	dict.insert(make_pair("left", "左边"));
  40. 	dict.insert(make_pair("left", "剩余"));
  41. 	dict["string"];
  42. 	dict["left"] = "剩余";
  43. 	dict["string"] = "字符串";
  44. 	//迭代器遍历
  45. 	//std::unordered_map<string, string>::iterator it = dict.begin();
  46. 	auto it = dict.begin();
  47. 	while (it != dict.end())
  48. 	{
  49. 		cout << it->first << " " << it->second << endl;
  50. 		++it;
  51. 	}
  52. 	cout << endl;
  53. 	//范围for遍历
  54. 	for (auto& kv : dict)
  55. 	{
  56. 		cout << kv.first << " " << kv.second << endl;
  57. 	}
  58. }
  59. //
  60. //2.模拟实现UnorderedSet、UnorderedMap测试
  61. void test_my_UnorderedSet()
  62. {
  63. 	my::unordered_set<int> s;
  64. 	s.insert(9);
  65. 	s.insert(7);
  66. 	s.insert(2);
  67. 	s.insert(1);
  68. 	s.insert(6);
  69. 	s.insert(5);
  70. 	//1.迭代器遍历
  71. 	//my::unordered_set<int>::iterator it = s.begin();
  72. 	//auto it = s.begin();
  73. 	//写法2：
  74. 	my::unordered_set<int>::iterator it;
  75. 	it = s.begin();
  76. 	while (it != s.end())
  77. 	{
  78. 		cout << *it << " ";
  79. 		++it;
  80. 	}
  81. 	cout << endl;
  82. 	//2.范围for遍历
  83. 	for (auto e : s)
  84. 	{
  85. 		cout << e << " ";
  86. 	}
  87. 	cout << endl;
  88. }
  89. void test_my_UnorderedMap()
  90. {
  91. 	my::unordered_map<string, string> dict;
  92. 	dict.insert(make_pair("sort", "排序"));
  93. 	dict.insert(make_pair("left", "左边"));
  94. 	dict.insert(make_pair("left", "剩余"));
  95. 	dict["string"];
  96. 	dict["left"] = "剩余";
  97. 	dict["string"] = "字符串";
  98. 	//迭代器遍历
  99. 	//my::unordered_map<string, string>::iterator it = dict.begin();
  100. 	auto it = dict.begin();
  101. 	while (it != dict.end())
  102. 	{
  103. 		cout << it->first << " " << it->second << endl;
  104. 		++it;
  105. 	}
  106. 	cout << endl;
  107. 	//范围for遍历
  108. 	for (auto& kv : dict)
  109. 	{
  110. 		cout << kv.first << " " << kv.second << endl;
  111. 	}
  112. }
  113. int main()
  114. {
  115. 	//test_std_UnorderedSet();
  116. 	//test_std_UnorderedMap();
  117.  
  118. 	//test_my_UnorderedSet();
  119. 	test_my_UnorderedMap();
  120.  
  121. 	return 0;
  122. }

 

测试示例：

 

 

 

 

后记：
●由于作者水平有限，文章难免存在谬误之处，敬请读者斧正，俚语成篇，恳望指教！

                                                                           ——By 作者：新晓·故知

 

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

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

  

闽ICP备14008679号