碎碎念：

C++11定义了四个无序容器，说是无序，即容器里面的元素关键字无序，因为这些容器不是使用比较运算符来组织元素，而是使用一个哈希函数，和关键字类型的==运算符。

对我们普通人来说，一般考虑的都是它的使用场合和其常用的成员函数，所以我们先来介绍这两个东西。这里拿map举例，set同理。

使用场合：

无序容器支持对单个元素的快速检索，元素在无序容器里面没有被排序，而是依靠他们的哈希值被组织进叫做桶的数据结构中。无序容器比map检索速度快。支持下标访问。

我们知道，map底层是红黑树，查找效率是logn，而无序容器底层是哈希表，查找效率是常数级别。所以，C++primer上说，在关键字类型的元素没有明显的序的情况下，或者在某些应用中，维护元素有序的代价非常高昂，采用无序容器代替map来说效果会好。

常用的函数：

1.使用无序容器必须加头文件： #include

2.初始化：

unordered_map A({ {"123", 1},{"456",4} });//C++11列表初始化

unordered_map B(A);//copy

unordered_map C(A.begin(), A.end());//range

3.更新：

unordered_map A{ {"123", 1},{"456",4} };

unordered_map B{ {"789", 7},{"101112",10} };

3.1 insert()

A.insert(make_pair("123", 5))//插入单个pair

A.insert({ "123", 5 });//插入单个pair

A.insert({{ "123", 5 }, { "456",4 }});//插入多个pair

A.insert(B.begin(),B.end())//插入一个无序容器。

3.2 emplace()添加

unordered_map A{ {"123", 1},{"456",4} };

A.emplace("5",4);

3.3 insert()和emplace()区别

c++11标准引入了emplace()，与insert()相对应。empalce操作构造而不是拷贝元素。

1.当我们调用insert()时，我们将元素类型的对象传递给它们，这些类型被拷贝到容器中。

2.当我们调用emplace()，会在容器管理的内存空间内直接创建对象。

注：

1.emplace()的参数根据元素的类型变化，参数必须与元素类型的构造函数相匹配。

2.insert()和emplace()只有在关键值key在容器中不存在时，才会把该元素插入容器中。

否则如果容器中有关键值为key的元素，则什么也不做。

3.insert和emplace的返回值是一个pair，它的first是一个迭代器，指向具有给定关键字的元素，second是一个bool，指出元素是否插入成功。

4.容量相关

unordered_map A{ {"123", 1},{"456",4} };

A.size() //返回容器的容量

A.empty()//如果容器为空，返回true，否则返回false

A.max_size()//返回最大容量

5.元素访问

5.1 下标访问

unordered_map A{ {"123", 1},{"456",4} };

1. A["789"]=7;

如果key为"789"的元素不存在，则插入一个新的元素到容器。

如果key为"789"的元素存在，则保留它的key，更新它的value。

2. int i=A["101"];

如果key为"101"的元素不存在，则返回其对应类型的初始值，int为0。

如果key为"101"的元素存在，则返回其value。

5.2 at访问

unordered_map A{ {"123", 1},{"456",4} };

1.A.at("123")=5;

如果key为"123"的元素存在，则更新其value。如果不存在，抛出一个异常。

http://2.int i=A.at("123");

如果key为"123"的元素存在，则返回其value，如果不存在，则抛出一个异常。

5.3 下标访问和at访问的区别：

at访问时，如果元素的key值不存在，会抛出异常，

下标访问如果元素的key值不存在，则添加一个关键之为key的元素，并对其进行值初始化。

6.查找元素

unordered_map A{ {"123", 1},{"456",4} };

1.A.find("123");

如果找到了key为123的元素，则返回其对应的迭代器，如果没找到，则返回A.end();

常用的用法为if(A.find("123")!=A.end()){}//如果找到了。

2.A.count("123");

如果容器中有key为123的元素，则返回其个数，在map中也就是1，不存在返回0；

7.删除元素。

unordered_map A{ {"123", 1},{"456",4} };

1.A.erase("123");//从A中删除每个关键字为"123"的元素。返回删除元素的个数。

2.auto w=A.find("123"); A.erase(w)//从A中删除迭代器w指向的元素。返回w之后元素的迭代器。

8.清空容器

unordered_map A{ {"123", 1},{"456",4} };

A.clear();//所有的元素从容器中移除，并且调用他们的构造函数，容器的大小变为0.

9.关于桶的函数:

unordered_map A{ {"123", 1},{"456",4} };

9.1桶的接口

1. A.bucket_count(); //返回正在使用的桶的数目

2. A.max_bucket_count()//容器能容纳的最多的桶的数目

3. A.bucket_size(n) //第n个桶中有多少元素

4. A.bucket(k) //关键字为K的元素在第几个桶中，返回的是int。

9.2哈希策略

1. A.load_factor() //返回每个桶的平均元素数量 float值。 A.size()/A.bucket_count()

2. A.rehash(n)//重组存储，使得桶的数量大于n

3. A.reserve(n)//通过设置预期容器的大小，使得我们不必因为元素的增加多次重组存储。

9.3桶迭代

1. A.begin(n)，A.end(n)//返回桶n的首元素迭代器和尾后迭代器。

举例:依次输出每个桶中的元素：

int main()

{

std::unordered_map<:string std::string> mymap;

mymap = { { "Australia","Canberra" },{ "U.S.","Washington" },{ "France","Paris" } };

std::cout << "mymap contains:";

for (auto it = mymap.begin(); it != mymap.end(); ++it)

std::cout << " " << it->first << ":" << it->second;

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.begin(i); local_it != mymap.end(i); ++local_it)

{

std::cout << " " << local_it->first << ":" << local_it->second;

}

std::cout << std::endl;

}

system("pause");

return 0;

}