文章目录

• 1. std::unordered_map 的定义与特性
• 2. 构造 std::unordered_map
• 3. 赋值操作
• 4. 迭代器操作
• • 4.1 指向整个容器中的元素
  • 4.2 指向某个桶中的元素
• 5. 容量操作
• 6. 访问操作
• 7. 插入操作
• 8. 删除操作
• 9. 查找操作
• 10. 桶操作

1. std::unordered_map 的定义与特性

• 所在头文件：<unordered_map>

• std::unorederd_map类模板：

template < class Key,                                    // unordered_map::key_type
           class T,                                      // unordered_map::mapped_type
           class Hash = hash<Key>,                       // unordered_map::hasher
           class Pred = equal_to<Key>,                   // unordered_map::key_equal
           class Alloc = allocator< pair<const Key,T> >  // unordered_map::allocator_type
           > class unordered_map;

• 关联性：std::unorederd_map 是一个关联容器，其中的元素根据键来引用，而不是根据索引来引用。

• 无序性：在内部，std::unordered_map中的元素不会根据其键值或映射值按任何特定顺序排序，而是根据其哈希值组织到桶中，以允许通过键值直接快速访问各个元素（常量的平均时间复杂度）。

• 唯一性：std::unorederd_map中的元素的键是唯一的。

一些类型定义：

2. 构造 std::unordered_map

参数解释：
n ： 初始时，桶的最小数量，即最少有多少个桶。
hf ： 哈希函数对象。它是一个函数，根据传递给它的键计算并返回一个整数。
eql ： 比较函数对象。如果传递给它的两个参数相等，则返回true.

例子：

// constructing unordered_maps
#include <iostream>
#include <string>
#include <unordered_map>

typedef std::unordered_map<std::string,std::string> stringmap;

stringmap merge (stringmap a,stringmap b) {
  	stringmap temp(a); 
  	temp.insert(b.begin(),b.end()); 
  	return temp;
}

int main () {
	  stringmap first;                              // empty

	  // 一个元素为：{key, value}
	  stringmap second ( {{"apple","red"}, {"lemon","yellow"}} );       // init list
	  stringmap third ( {{"orange","orange"}, {"strawberry","red"}} );  // init list
	  stringmap fourth (second);                    // copy
	  stringmap fifth (merge(third,fourth));        // move
	  stringmap sixth (fifth.begin(),fifth.end());  // range
	
	  std::cout << "sixth contains:"<<endl;
	  for (auto& x: sixth) 
	  		std::cout << x.first << ":" << x.second<<endl;
	  std::cout << std::endl;
	  system("pause");
	  return 0;
}

运行结果：

3. 赋值操作

例子：

// assignment operator with unordered_map
#include <iostream>
#include <string>
#include <unordered_map>

typedef std::unordered_map<std::string, std::string> stringmap;

stringmap merge(stringmap a, stringmap b) {
	stringmap temp(a);
	temp.insert(b.begin(), b.end());
	return temp;
}

int main() {
	//stringmap first, second, third;//此处连续定义三个会报错。
	stringmap  first = { { "AAPL", "Apple" }, { "MSFT", "Microsoft" } };  // init list
	stringmap second = { { "GOOG", "Google" }, { "ORCL", "Oracle" } };   // init list
	stringmap third = merge(first, second);                       // move
	first = third;                                     // copy

	std::cout << "first contains:"<<std::endl;
	for (auto& elem : first)
		std::cout << elem.first << ":" << elem.second<<std::endl;
	std::cout << std::endl;
	system("pause");
	return 0;
}

运行结果：

4. 迭代器操作

4.1 指向整个容器中的元素

即，“第一个”指整个容器中的第一个，“尾后”指整个容器中的尾后。

4.2 指向某个桶中的元素

即，“第一个”指某个桶中的第一个，“尾后”指某个桶中的尾后。

例子：

// unordered_map::cbegin/cend example
#include <iostream>
#include <string>
#include <unordered_map>

int main() {
	std::unordered_map<std::string, std::string> mymap= { { "Australia", "Canberra" }, { "U.S.", "Washington" }, { "France", "Paris" } };

	std::cout << "mymap contains:"<<std::endl;
	for (auto it = mymap.cbegin(); it != mymap.cend(); ++it)
		std::cout << it->first << ":" << it->second<<std::endl;  // cannot modify *it
	std::cout << std::endl;

	std::cout << "mymap's buckets contain:\n";
	for (unsigned i = 0; i < mymap.bucket_count(); ++i) {
		std::cout << "bucket #" << i << " contains:";
		for (auto local_it = mymap.cbegin(i); local_it != mymap.cend(i); ++local_it)
			std::cout << local_it->first << ":" << local_it->second;
		std::cout << std::endl;
	}
	system("pause");
	return 0;
}

运行结果：

5. 容量操作

6. 访问操作

注意：const std::unordered_map 不能使用 operator[] 操作！！

例子：

// unordered_map::at
#include <iostream>
#include <string>
#include <unordered_map>

int main() {
	std::unordered_map<std::string, int> mymap = {
		{ "Mars", 3000 },
		{ "Saturn", 60000 },
		{ "Jupiter", 70000 } };

	mymap.at("Mars") = 3396;
	mymap.at("Saturn") += 272;
	mymap.at("Jupiter") = mymap.at("Saturn") + 9638;

	for (auto& x : mymap) {
		std::cout << x.first << ": " << x.second << std::endl;
	}
	system("pause");
	return 0;
}

运行结果：

7. 插入操作

例子：

// unordered_map::insert
#include <iostream>
#include <string>
#include <unordered_map>

int main() {
	std::unordered_map<std::string, double>
		myrecipe,
		mypantry = { { "milk", 2.0 }, { "flour", 1.5 } };

	std::pair<std::string, double> myshopping("baking powder", 0.3);

	myrecipe.insert(myshopping);                        // copy insertion
	myrecipe.insert(std::make_pair<std::string, double>("eggs", 6.0)); // move insertion
	myrecipe.insert(mypantry.begin(), mypantry.end());  // range insertion
	myrecipe.insert({ { "sugar", 0.8 }, { "salt", 0.1 } });    // initializer list insertion

	std::cout << "myrecipe contains:" << std::endl;
	for (auto& x : myrecipe)
		std::cout << x.first << ": " << x.second << std::endl;

	std::cout << std::endl;
	system("pause");
	return 0;
}

运行结果：

8. 删除操作

例子：

// unordered_map::erase
#include <iostream>
#include <string>
#include <unordered_map>

int main() {
	std::unordered_map<std::string, std::string> mymap;

	// populating container:
	mymap["U.S."] = "Washington";
	mymap["U.K."] = "London";
	mymap["France"] = "Paris";
	mymap["Russia"] = "Moscow";
	mymap["China"] = "Beijing";
	mymap["Germany"] = "Berlin";
	mymap["Japan"] = "Tokyo";

	// erase examples:
	mymap.erase(mymap.begin());      // erasing by iterator
	mymap.erase("France");             // erasing by key
	mymap.erase(mymap.find("China"), mymap.end()); // erasing by range

	// show content:
	for (auto& x : mymap)
		std::cout << x.first << ": " << x.second << std::endl;
	system("pause");
	return 0;
}

运行结果：

9. 查找操作

例子：

// unordered_map::find
#include <iostream>
#include <string>
#include <unordered_map>

int main () {
	  std::unordered_map<std::string,double> mymap = {
	     {"mom",5.4},
	     {"dad",6.1},
	     {"bro",5.9} };
	
	  std::string input;
	  std::cout << "who? ";
	  getline (std::cin,input);
	
	  // 查找
	  std::unordered_map<std::string,double>::const_iterator got = mymap.find (input);
	
	  if ( got == mymap.end() )
	      std::cout << "not found";
	  else
	      std::cout << got->first << " is " << got->second;
	
	  std::cout << std::endl;
	  system("pause");
	  return 0;
}

运行结果：

10. 桶操作

参考：http://www.cplusplus.com/reference/unordered_map/unordered_map/

---

以上博文来自：

• W.T.F._C++ std::unordered_map 用法详解