• C++ 哈希桶模拟实现(补充)

    目录

    定义基本的存储结构

    Insert()和Find()

    Erase()

    如何控制哈希冲突？

    Insert()中添加扩容操作

    其他问题的解决

     

    UnorderedMap.h和UnorderedSet.h

    迭代器实现与UnorderedMap.h和UnorderedSet.h的封装

    定义基本的存储结构

    1. #pragma once
    2. #include
    3. #include
    4. using namespace std;
    5. namespace OpenHash
    6. {
    7. 	template<class K,class V>
    8. 	struct HashNode
    9. 	{
    10. 		HashNode* _next;
    11. 		pair _kv;
    12.  
    13.  
    14.         //构造函数
    15.         HashNode(const pair& kv)
    16. 			:_next(nullptr)
    17. 			,_kv(kv)
    18. 		{}
    19. 	};
    20.  
    21. 	template<class K,class V>
    22. 	class HashTable
    23. 	{
    24. 		typedef HashNodeNode;
    25. 	public:
    26. 		//待写
    27. 	private:
    28. 		vector _table;
    29. 		size_t _n = 0;    //有效数据的个数
    30. 	};
    31. }

    Insert()和Find()

    1. bool Insert(const pair& kv)
    2. {
    3. 	//Find()函数防止冗余
    4. 	if (Find(kv.first))
    5. 		return false;
    6.  
    7. 	size_t index = kv.first % _table.size();
    8. 	//采用头插法，尾插法还需要找尾，麻烦
    9. 	Node* newnode = new Node(kv);
    10.  
    11. 	newnode->_next = _table[index];
    12. 	_table[index] = newnode;
    13. 	++_n;
    14.  
    15. 	return true;
    16. }
    17.  
    18. Node* Find(const K& key)
    19. {
    20. 	size_t index = kv.first % _table.size();
    21. 	Node* cur = _table[index];
    22. 	while (cur)
    23. 	{
    24. 		if (cur->_kv.first == key)
    25. 		{
    26. 			return cur;
    27. 		}
    28. 		else
    29. 		{
    30. 			cur = cur->_next;
    31. 		}
    32. 	}
    33. 	return nullptr;
    34. }

    Erase()

    思考：如果单链表不给头结点，如何删除指定节点？采用替换法删除

    将下一个节点的值赋给指定节点，再删除下一个节点

     思考：采用替换法如何删除尾节点？以下图为例，删除104节点

     

    1. bool Erase(const K& key)
    2. {
    3. 	size_t index = kv.first % _table.size();
    4. 	Node* prev = nullptr;
    5. 	Node* cur = _table[index];
    6. 	while (cur)
    7. 	{
    8. 		if (cur->_kv.first == key)
    9. 		{
    10. 			if (_table[index] == cur)
    11. 			{
    12. 				_table[index] = cur->_next;
    13. 			}
    14. 			else
    15. 			{
    16. 				prev->_next = cur->_next;
    17. 			}
    18. 			--_n;
    19. 			delete cur;
    20. 			return true;
    21. 		}
    22. 		prev = cur;
    23. 		cur = cur->_next;
    24. 	}
    25. 	return false;
    26. }

    如何控制哈希冲突？

     

    Insert()中添加扩容操作

    1. bool Insert(const pair& kv)
    2. {
    3. 	//Find()函数防止冗余
    4. 	if (Find(kv.first))
    5. 		return false;
    6.  
    7. 	//负载因子到1的时候增容
    8. 	//负载因子为0的时候要防止除零错误
    9. 	if (_n == _table.size())
    10. 	{
    11. 		vector newtable;
    12. 		size_t newSize = _table.size() == 0 ? 10 : _table.size() * 2;
    13. 		newtable.resize(newSize, nullptr);
    14.  
    15. 		//遍历取旧表中节点，重新算映射到新表中的位置，挂到新表中
    16. 		for (size_t i = 0; i < _table.size(); ++i)
    17. 		{
    18. 			if (_table[i])//operator[]会检查给的下标是否在0到size这个范围之内
    19. 			{
    20. 				Node* cur = _table[i];
    21. 				while (cur)//若不为空，则把该桶取完，计算其在新表中的位置
    22. 				{
    23. 					Node* next = cur->_next;//保存cur的下一个节点
    24. 					size_t index = cur->_kv.first % newtable.size();
    25. 					//头插
    26. 					cur->_next = newtable[index];
    27. 					_table[index] = cur;
    28.  
    29. 					cur = next;
    30. 				}
    31. 				_table[i] = nullptr;//都处理完后旧表的当前位置可置空
    32. 			}
    33. 		}
    34. 		_table.swap(newtable); //交换新旧表
    35. 	}
    36.  
    37. 	size_t index = kv.first % _table.size();
    38. 	//采用头插法，尾插法还需要找尾，麻烦
    39. 	Node* newnode = new Node(kv);
    40.  
    41. 	newnode->_next = _table[index];
    42. 	_table[index] = newnode;
    43. 	++_n;
    44.  
    45. 	return true;
    46. }

     

    其他问题的解决

    1.K不支持取模的情况？提供一个默认返回的仿函数，再提供一个特化的仿函数。后续需要取模的地方使用仿函数即可(详细见全部代码)

    1. template<class K>
    2. struct Hash
    3. {
    4. 	size_t operator()(const K& key)
    5. 	{
    6. 		return key;
    7. 	}
    8. };
    9.  
    10. // 特化
    11. template<>
    12. struct Hash
    13. {
    14. 	// "int"  "insert" 
    15. 	// 字符串转成对应一个整形值，因为整形才能取模算映射位置
    16. 	// 期望->字符串不同，转出的整形值尽量不同
    17. 	// "abcd" "bcad"
    18. 	// "abbb" "abca"
    19. 	size_t operator()(const string& s)
    20. 	{
    21. 		// BKDR Hash
    22. 		size_t value = 0;
    23. 		for (auto ch : s)
    24. 		{
    25. 			value += ch;
    26. 			value *= 131;
    27. 		}
    28.  
    29. 		return value;
    30. 	}
    31. };

    2.除了控制负载因子，尽量让表的大小为素数也可以控制哈希冲突。但是此时对于增容的挑战很大：要保证增容二倍后还是表的大小还是素数。->通过素数表解决

    1.  
    2. //提供一个素数表(来自STL源码)
    3. size_t GetNextPrime(size_t prime)
    4. {
    5. 	const int PRIMECOUNT = 28;
    6. 	static const size_t primeList[PRIMECOUNT] =  //定义成静态的，不用每次重新创建数组
    7. 	{
    8. 		53ul, 97ul, 193ul, 389ul, 769ul,
    9. 		1543ul, 3079ul, 6151ul, 12289ul, 24593ul,
    10. 		49157ul, 98317ul, 196613ul, 393241ul, 786433ul,
    11. 		1572869ul, 3145739ul, 6291469ul, 12582917ul, 25165843ul,
    12. 		50331653ul, 100663319ul, 201326611ul, 402653189ul, 805306457ul,
    13. 		1610612741ul, 3221225473ul, 4294967291ul
    14. 	};
    15.  
    16. 	size_t i = 0;
    17. 	for (; i < PRIMECOUNT; ++i)
    18. 	{
    19. 		//获取一个比当前素数要大的数
    20. 		if (primeList[i] > prime)
    21. 			return primeList[i];
    22. 	}
    23.  
    24. 	return primeList[i];
    25. }

    此时增容函数就可进行修改

    1. bool Insert(const pair& kv)
    2. {
    3. 	//Find()函数防止冗余
    4. 	if (Find(kv.first))
    5. 		return false;
    6.  
    7. 	HashFunc hf;
    8.  
    9. 	//负载因子到1的时候增容
    10. 	//负载因子为0的时候要防止除零错误
    11. 	if (_n == _table.size())
    12. 	{
    13. 		vector newtable;
    14. 		//size_t newSize = _table.size() == 0 ? 10 : _table.size() * 2;
    15. 		//newtable.resize(newSize, nullptr);
    16. 		newtable.resize(GetNextPrime(_table.size()));//通过素数表可重新写增容函数
    17.  
    18. 		//遍历取旧表中节点，重新算映射到新表中的位置，挂到新表中
    19. 		for (size_t i = 0; i < _table.size(); ++i)
    20. 		{
    21. 			if (_table[i])//operator[]会检查给的下标是否在0到size这个范围之内
    22. 			{
    23. 				Node* cur = _table[i];
    24. 				while (cur)//若不为空，则把该桶取完，计算其在新表中的位置
    25. 				{
    26. 					Node* next = cur->_next;//保存cur的下一个节点
    27. 					size_t index = hf(cur->_kv.first) % newtable.size();
    28. 					//头插
    29. 					cur->_next = newtable[index];
    30. 					_table[index] = cur;
    31.  
    32. 					cur = next;
    33. 				}
    34. 				_table[i] = nullptr;//都处理完后旧表的当前位置可置空
    35. 			}
    36. 		}
    37. 		_table.swap(newtable); //交换新旧表
    38. 	}
    39.  
    40. 	size_t index = hf(kv.first) % _table.size();
    41. 	//采用头插法，尾插法还需要找尾，麻烦
    42. 	Node* newnode = new Node(kv);
    43.  
    44. 	newnode->_next = _table[index];
    45. 	_table[index] = newnode;
    46. 	++_n;
    47.  
    48. 	return true;
    49. }

     

    UnorderedMap.h和UnorderedSet.h

    1. #pragma once
    2. #include"HashTable.h"
    3.  
    4. namespace bit
    5. {
    6. 	template<class K, class V>
    7. 	class unordered_map
    8. 	{
    9. 	public:
    10. 		struct MapKeyOfT
    11. 		{
    12. 			const K& operator()(const pair& kv)
    13. 			{
    14. 				return kv.first;
    15. 			}
    16. 		};
    17.  
    18. 		bool Insert(const pair& kv)
    19. 		{
    20. 			_ht.Insert(kv);
    21. 			return true;
    22. 		}
    23.  
    24. 	private:
    25. 		OpenHash::HashTable, MapKeyOfT>_ht;
    26. 	};
    27. }
    1. #pragma once
    2. #include"HashTable.h"
    3.  
    4. namespace bit
    5. {
    6. 	template<class K, class V>
    7. 	class unordered_set
    8. 	{
    9. 	public:
    10. 		struct SetKeyOfT
    11. 		{
    12. 			const K& operator()(const K& k)
    13. 			{
    14. 				return k;
    15. 			}
    16. 		};
    17.  
    18. 		bool Insert(const K k)
    19. 		{
    20. 			_ht.Insert(k);
    21. 			return true;
    22. 		}
    23.  
    24. 	private:
    25. 		OpenHash::HashTable_ht;
    26. 	};
    27. }

    迭代器实现与UnorderedMap.h和UnorderedSet.h的封装

    各个部分的改动和添加看注释即可，最终整体代码如下

    1. #pragma once
    2. #include
    3. #include
    4. using namespace std;
    5. namespace OpenHash
    6. {
    7. 	template<class K>
    8. 	struct Hash
    9. 	{
    10. 		size_t operator()(const K& key)
    11. 		{
    12. 			return key;
    13. 		}
    14. 	};
    15.  
    16. 	// 特化
    17. 	template<>
    18. 	struct Hash
    19. 	{
    20. 		// "int"  "insert" 
    21. 		// 字符串转成对应一个整形值，因为整形才能取模算映射位置
    22. 		// 期望->字符串不同，转出的整形值尽量不同
    23. 		// "abcd" "bcad"
    24. 		// "abbb" "abca"
    25. 		size_t operator()(const string& s)
    26. 		{
    27. 			// BKDR Hash
    28. 			size_t value = 0;
    29. 			for (auto ch : s)
    30. 			{
    31. 				value += ch;
    32. 				value *= 131;
    33. 			}
    34.  
    35. 			return value;
    36. 		}
    37. 	};
    38. 	
    39. 	template<class T>
    40. 	struct HashNode
    41. 	{
    42. 		HashNode* _next;
    43. 		T _data;
    44.  
    45. 		HashNode(const T& data)
    46. 			:_next(nullptr)
    47. 			,_data(data)
    48. 		{}
    49. 	};
    50.  
    51. 	//前置声明
    52. 	//前置声明不需要给默认参数
    53. 	template<class K, class T, class KeyOfT, class HashFunc>
    54. 	class HashTable;
    55.  
    56.  
    57. 	//哈希桶迭代器
    58. 	template<class K, class T, class KeyOfT, class HashFunc = Hash>
    59. 	struct _HTIterator
    60. 	{
    61. 		typedef HashNode Node;
    62. 		typedef _HTIteratorSelf;
    63. 		typedef HashTableHT;
    64. 		Node* _node;
    65. 		HT* _pht;//传哈希表的指针
    66.  
    67. 		_HTIterator(Node* node,HT* pht)
    68. 			:_node(node)
    69. 			,_pht(pht)
    70. 		{}
    71.  
    72. 		Self& operator++()
    73. 		{
    74. 			//1.当前桶中还有数据，那么就在当前桶往后走
    75. 			//2.当前桶走完了，需要往下一个桶去走
    76. 			if (_node->_next)
    77. 			{
    78. 				_node = _node->_next;
    79. 			}
    80. 			else
    81. 			{
    82. 				//迭代器走到当前桶的最后一个位置的时候如何进入下一个桶？
    83. 				_pht->_table.size();
    84. 				KeyOfT kot;
    85. 				HashFunc hf;
    86. 				size_t index = hf(kot(_node->_data)) % _pht->_table.size();//算出当前桶的位置
    87. 				//通过keyoft的仿函数取出data里面的k取出，k再通过HashFunc的仿函数转换成可以取模的整型
    88. 				++index;
    89. 				while (index < _pht->_table.size())
    90. 				{
    91. 					if (_pht->_table[index])//找到下一个桶了
    92. 					{
    93. 						_node = _pht->_table[index];//指向桶里面的第一个节点
    94. 						return *this;
    95. 					}
    96. 					else
    97. 					{
    98. 						++index;
    99. 					}
    100. 				}
    101. 				
    102. 				//return iterator(nullptr, _pht);//后面没有桶了，返回空的迭代器
    103. 				_node = nullptr;
    104. 				 
    105. 			}
    106. 			return *this;
    107. 		}
    108.  
    109. 		T& operator*()
    110. 		{
    111. 			return _node->_data;
    112. 		}
    113.  
    114. 		T* operator->()
    115. 		{
    116. 			return &_node->_data;
    117. 		}
    118.  
    119. 		bool operator != (const Self& s)const
    120. 		{
    121. 			return _node != s._node;
    122. 		}
    123.  
    124. 		bool operator == (const Self& s)const
    125. 		{
    126. 			return _node == s._node;
    127. 		}
    128. 	};
    129.  
    130. 	template<class K,class T, class KeyOfT,class HashFunc = Hash>
    131. 	class HashTable
    132. 	{
    133. 		typedef HashNodeNode;
    134.  
    135. 		//设计类模板的友元
    136. 		template<class K, class T, class KeyOfT, class HashFunc>//需要添加模板参数
    137. 		friend struct _HTIterator;
    138. 	
    139. 	public:
    140. 		typedef _HTIterator iterator;
    141.  
    142. 		//默认的构造
    143. 		HashTable() = default; //C++11关键词：显示指定生成默认构造
    144.  
    145.  
    146. 		 //拷贝构造赋值
    147. 		HashTable(const HashTable& ht)
    148. 		{
    149. 			//深拷贝
    150. 			_n = ht._n;
    151. 			_table.resize(ht._table.size());
    152. 			for (size_t i = 0; i < ht._table.size(); i++)
    153. 			{
    154. 				Node* cur = ht._table[i];
    155. 				while (cur)
    156. 				{
    157. 					Node* copy = new Node(cur->_data);
    158. 					//头插到新表
    159. 					copy->_next = table[i];
    160. 					_table[i] = copy;
    161.  
    162. 					cur = cur->_next;
    163. 				}
    164. 			}
    165. 		}
    166.  
    167. 		//赋值
    168. 		HashTable& operator=(const HashTable ht)
    169. 		{
    170. 			_table.swap(ht._table);
    171. 			swap(_n,ht._n);
    172. 			
    173. 			return *this;
    174. 		}
    175.  
    176. 		//析构
    177. 		~HashTable()
    178. 		{
    179. 			for (size_t i = 0; i < _table.size();i++)
    180. 			{
    181. 				Node* cur = _table[i];
    182. 				while (cur)
    183. 				{
    184. 					Node* next = cur->_next;//保存当前节点
    185. 					delete cur; //释放当前节点
    186. 					cur = next;
    187. 				}
    188. 				_table[i] = nullptr;
    189. 			}
    190. 		}
    191.  
    192. 		iterator begin()
    193. 		{
    194. 			//返回第一个桶里面的第一个节点
    195. 			size_t i = 0;
    196. 			while (i<_table.size())
    197. 			{
    198. 				if (_table[i])//不为空就找到第一个桶
    199. 				{
    200. 					return iterator(_table[i],this);//迭代器需要一个节点的指针，_table[i]就是节点的指针
    201. 				    //成员函数this就是自己对象的地址,即this就是哈希表的地址
    202. 				}
    203. 				++i;
    204. 			}
    205. 			return end();
    206. 		}
    207.  
    208. 		iterator end()
    209. 		{
    210. 			return iterator(nullptr, this);
    211. 		}
    212.  
    213. 		//提供一个素数表(来自STL源码)
    214. 		size_t GetNextPrime(size_t prime)
    215. 		{
    216. 			const int PRIMECOUNT = 28;
    217. 			static const size_t primeList[PRIMECOUNT] =  //定义成静态的，不用每次重新创建数组
    218. 			{
    219. 				53ul, 97ul, 193ul, 389ul, 769ul,
    220. 				1543ul, 3079ul, 6151ul, 12289ul, 24593ul,
    221. 				49157ul, 98317ul, 196613ul, 393241ul, 786433ul,
    222. 				1572869ul, 3145739ul, 6291469ul, 12582917ul, 25165843ul,
    223. 				50331653ul, 100663319ul, 201326611ul, 402653189ul, 805306457ul,
    224. 				1610612741ul, 3221225473ul, 4294967291ul
    225. 			};
    226.  
    227. 			size_t i = 0;
    228. 			for (; i < PRIMECOUNT; ++i)
    229. 			{
    230. 				//获取一个比当前素数要大的数
    231. 				if (primeList[i] > prime)
    232. 					return primeList[i];
    233. 			}
    234.  
    235. 			return primeList[i];
    236. 		}
    237.  
    238.  
    239. 		pairbool> Insert(const T& data)
    240. 		{ 
    241. 			KeyOfT kot;
    242. 			//找到了
    243. 			auto ret = Find(kot(data));
    244. 			if(ret != end())
    245. 				return make_pair(ret,false);
    246.  
    247. 			HashFunc hf;
    248.  
    249. 			//负载因子到1的时候增容
    250. 			//负载因子为0的时候要防止除零错误
    251. 			if (_n == _table.size())
    252. 			{
    253. 				vector newtable;
    254. 				//size_t newSize = _table.size() == 0 ? 10 : _table.size() * 2;
    255. 				//newtable.resize(newSize, nullptr);
    256. 				newtable.resize(GetNextPrime(_table.size()));//通过素数表可重新写增容函数
    257.  
    258. 				//遍历取旧表中节点，重新算映射到新表中的位置，挂到新表中
    259. 				for (size_t i = 0; i < _table.size(); ++i)
    260. 				{
    261. 					if (_table[i])//operator[]会检查给的下标是否在0到size这个范围之内
    262. 					{
    263. 						Node* cur = _table[i];
    264. 						while (cur)//若不为空，则把该桶取完，计算其在新表中的位置
    265. 						{
    266. 							Node* next = cur->_next;//保存cur的下一个节点
    267. 							size_t index = hf(kot(cur->_data)) % newtable.size();
    268. 							//头插
    269. 							cur->_next = newtable[index];
    270. 							_table[index] = cur;
    271.  
    272. 							cur = next;
    273. 						}
    274. 						_table[i] = nullptr;//都处理完后旧表的当前位置可置空
    275. 					}
    276. 				}
    277. 				_table.swap(newtable); //交换新旧表
    278. 			}
    279.  
    280. 			size_t index = hf(kot(data)) % _table.size();
    281. 			//采用头插法，尾插法还需要找尾，麻烦
    282. 			Node* newnode = new Node(data);
    283. 			
    284. 			newnode->_next = _table[index];
    285. 			_table[index] = newnode;
    286. 			++_n;
    287.  
    288. 			return make_pair(iterator(newnode, this), true);
    289.  
    290. 		}
    291.  
    292. 		iterator Find(const K& key)
    293. 		{
    294. 			if (_table.size() == 0)
    295. 			{
    296. 				return end();
    297. 			}
    298. 			KeyOfT kot;
    299. 			HashFunc hf;
    300. 			size_t index = hf(key) % _table.size();
    301. 			Node* cur = _table[index];
    302. 			while (cur)
    303. 			{
    304. 				if (kot(cur->_data) == key)
    305. 				{
    306. 					return iterator(cur,this);//Find的返回值为迭代器
    307. 				}
    308. 				else
    309. 				{
    310. 					cur = cur->_next;
    311. 				}
    312. 			}
    313. 			return end();
    314. 		}
    315.  
    316. 		bool Erase(const K& key)
    317. 		{
    318. 			size_t index = hf(kot(key)) % _table.size();
    319. 			Node* prev = nullptr;
    320. 			Node* cur = _table[index];
    321. 			while (cur)
    322. 			{
    323. 				if (kot(cur->data) == key)
    324. 				{
    325. 					if (_table[index] == cur)
    326. 					{
    327. 						_table[index] = cur->_next;
    328. 					}
    329. 					else
    330. 					{
    331. 						prev->_next = cur->_next;
    332. 					}
    333. 					--_n;
    334. 					delete cur;
    335. 					return true;
    336. 				}
    337. 				prev = cur;
    338. 				cur = cur->_next;
    339. 			}
    340. 			return false;
    341. 		}
    342.  
    343. 		void TestHashTable1()
    344. 		{
    345. 			int a[] = { 1,5,30,100000,100,18,15,7,40,44 };
    346. 			HashTable<int, int>ht;
    347. 			for (auto e : a)
    348. 			{
    349. 				ht.Insert(make_pair(e.e));
    350. 			}
    351. 			ht.Insert(make_pair(25, 25));
    352.  
    353. 		}
    354. 	private:
    355. 		vector _table;
    356. 		size_t _n = 0;    //有效数据的个数
    357. 	};
    358. }
    1. #pragma once
    2. #include "HashTable.h"
    3.  
    4. namespace bit
    5. {
    6.         template<class K>
    7.         class unordered_set
    8.         {
    9.                 struct SetKeyOfT
    10.                 {
    11.                         const K& operator()(const K& k)
    12.                         {
    13.                                 return k;
    14.                         }
    15.                 };
    16.         public:
    17.                 typedef typename OpenHash::HashTable::iterator iterator;
    18.                 iterator begin()
    19.                 {
    20.                         return _ht.begin();
    21.                 }
    22.  
    23.         iterator end()
    24.         {
    25.                 return _ht.end();
    26.         }
    27.  
    28.         pairbool> insert(const K k)
    29.         {
    30.                 return _ht.Insert(k);
    31.         }
    32.  
    33.         private:
    34.                 OpenHash::HashTable _ht;
    35.         };
    36.  
    37.         void test_unordered_set1()
    38.         {
    39.                 unordered_set<int> us;
    40.                 us.insert(200);
    41.                 us.insert(1);
    42.                 us.insert(2);
    43.                 us.insert(33);
    44.                 us.insert(50);
    45.                 us.insert(60);
    46.                 us.insert(243);
    47.                 us.insert(6);
    48.  
    49.         unordered_set<int>::iterator it = us.begin();
    50.         while (it != us.end())
    51.         {
    52.                 cout << *it << " ";
    53.                 ++it;
    54.         }
    55.         }
    56. }
    57.  
    1. #pragma once
    2. #include "HashTable.h"
    3.  
    4. namespace bit
    5. {
    6.     template<class K, class V>
    7.     class unordered_map
    8.     {
    9.         struct MapKeyOfT
    10.         {
    11.             const K& operator()(const pair& kv)
    12.             {
    13.                 return kv.first;
    14.             }
    15.         };
    16.     public:
    17.         typedef typename OpenHash::HashTable, MapKeyOfT>::iterator iterator;
    18.         iterator begin()
    19.         {
    20.             return _ht.begin();
    21.         }
    22.  
    23.         iterator end()
    24.         {
    25.             return _ht.end();
    26.         }
    27.  
    28.         pairbool> insert(const pair& kv)
    29.         {
    30.             return _ht.Insert(kv);
    31.         }
    32.  
    33.         V& operator[](const K& key)
    34.         {
    35.             pairbool> ret = _ht.Insert(make_pair(key, V()));
    36.             return ret.first->second;
    37.         }
    38.  
    39.     private:
    40.         OpenHash::HashTable, MapKeyOfT> _ht;
    41.     };
    42.  
    43.     void test_unordered_map1()
    44.     {
    45.         unordered_map dict;
    46.         dict.insert(make_pair("sort", "排序"));
    47.         dict["left"] = "左边";
    48.         dict["left"] = "剩余";
    49.         dict["map"] = "映射";
    50.         dict["string"] = "字符串ַ";
    51.         dict["set"] = "集合";
    52.  
    53.         unordered_map::iterator it = dict.begin();
    54.         while (it != dict.end())
    55.         {
    56.             cout << it->first << ":" << it->second << endl;
    57.             ++it;
    58.         }
    59.         cout << endl;
    60.     }
    61. }

  • 相关阅读:
    Dynamsoft Barcode Reader 9.4.0
    JavaScript 三种作用域 + 匿名函数 + 立即执行函数 详解
    【前端】webpack打包去除console.log
    聚观365|抖音上线“防打扰保护工具”；亚马逊拟计划裁员1万人
    文件共享方法
    springboot证书管理系统的设计与实现毕业设计源码162317
    JS中BigInt的使用
    小米手机买什么蓝牙耳机好？适配小米手机的蓝牙耳机推荐
    docker安装mysql并挂载配置文件和修改密码
    mongodb一些常用的查询语句
  • 原文地址：https://blog.csdn.net/m0_61548909/article/details/126600355