关联容器和顺序容器的本质差别在于：关联容器通过键（key）存储和读取元素，而顺序容器则通过元素在容器中的位置顺序存储和访问元素。
关联容器（Associative containers）支持通过键来高效地查找和读取元素。两个基本的关联容器类型是 map 和 set。
map 的元素以键－值（key-value）对的形式组织：键用作元素在 map 中的索引，而值则表示所存储和读取的数据。set 仅包含一个键，并有效地支持关于某个键是否存在的查询。
关联容器类型
|
map |
关联数组：元素通过键来存储和读取 |
|
set |
大小可变的集合，支持通过键实现的快速读取 |
|
multimap |
支持同一个键多次出现的 map 类型 |
|
multiset |
支持同一个键多次出现的 set 类型 |
一般来说，如果希望有效地存储不同值的集合，那么使用 set 容器比较合适，而 map 容器则更适用于需要存储（乃至修改）每个键所关联的值的情况。在做某种文本处理时，可使用 set 保存要忽略的单词。而字典则是 map 的一种很好的应用：单词本身是键，而它的解释说明则是值。
set 和 map 类型的对象所包含的元素都具有不同的键，不允许为同一个键添加第二个元素。如果一个键必须对应多个实例，则需使用 multimap 或 multi set，这两种类型允许多个元素拥有相同的键。
在开始介绍关联容器之前，必须先了解一种与之相关的简单的标准库类型—— pair，该类型在 utility 头文件中定义。
pairs 类型提供的操作
|
pair<T1, T2> p1; |
创建一个空的 pair 对象，它的两个元素分别是T1 和 T2 类型，采用值初始化 |
|
pair<T1, T2> p1(v1, v2); |
创建一个 pair 对象，它的两个元素分别是 T1 和 T2 ，其中 first 成员初始化为 v1，而 second 成员初始化为 v2 |
|
make_pair(v1, v2) |
以 v1 和 v2 值创建一个新 pair 对象，其元素类型分别是 v1 和 v2 的类型 |
|
p1 < p2 |
两个 pair 对象之间的小于运算，其定义遵循字典次序：如果 p1.first < p2.first 或者
!(p2.first < p1.first) && p1.second < p2.second，则返回 |
|
p1 == p2 |
如果两个 pair 对象的 first 和 second 成员依次相等，则这两个对象相等。该运算使用其元素的 == 操作符 |
|
p.first |
返回 p 中名为 first 的（公有）数据成员 |
|
p.second |
返回 p 的名为 second 的（公有）数据成员 |
pair 的创建和初始化
如果在创建 pair 对象时不提供初始化式，则调用默认构造函数对其成员采用值初始化。
strings pair<string, int> word_count; // holds a string and an int
pair<string, vector<int> > line; // holds string and vector<int>
pair<string, string> author("James", "Joyce");
pair 类型的使用相当繁琐，因此，如果需要定义多个相同的 pair 类型对象，可考虑利用 typedef 简化其声明：
与其他标准库类型不同，对于 pair 类，可以直接访问其数据成员：其成员都是公有的，分别命名为 first 和 second。
if (author.first == "James" && author.second == "Joyce")
{
firstBook = "Stephen Hero";
}
除了构造函数，标准库还定义了一个 make_pair 函数，由传递给它的两个实参生成一个新的 pair 对象。可如下使用该函数创建新的 pair 对象，并赋给已存在的 pair 对象：
string first, last;
while (cin >> first >> last)
{
// generate a pair from first and last
next_auth = make_pair(first, last);
// process next_auth...
}
make_pair 函数生成一个新的 pair 对象，此操作等价于下面更复杂的操作：
next_auth = pair<string, string > (first, last);
由于 pair 的数据成员是公有的，因而可如下直接地读取输入：
// read directly into the members of next_auth
while (cin >> next_auth.first >> next_auth.second)
{
// process next_auth...
}
“关联容器元素根据键的次序排列”这一事实就是一个重要的结论：在迭代遍历关联容器时，我们可确保按键的顺序的访问元素，而与元素在容器中的存放位置完全无关。
map 是键－值对的集合。map 类型通常可理解为关联数组（associative array）：可使用键作为下标来获取一个值，正如内置数组类型一样。而关联的本质在于元素的值与某个特定的键相关联，而并非通过元素在数组中的位置来获取。
map 对象的定义
|
map<k, v> m; |
创建一个名为 m 的空 map 对象，其键和值的类型分别为 k 和 v |
|
map<k, v> m(m2); |
创建 m2 的副本 m，m 与 m2 必须有相同的键类型和值类型 |
|
map<k, v> m(b, e); |
创建 map 类型的对象 m，存储迭代器 b 和 e 标记的范围内所有元素的副本。元素的类型必须能转换为 pair<const k, v> |
在实际应用中，键类型必须定义 < 操作符，而且该操作符应能“正确地工作”，这一点很重要。
在使用关联容器时，它的键不但有一个类型，而且还有一个相关的比较函数。
对于键类型，唯一的约束就是必须支持 < 操作符，至于是否支持其他的关系或相等运算，则不作要求。
map 对象的元素是键－值对，其 value_type 是存储元素的键以及值的 pair 类型，而且键为 const。
在学习 map 的接口时，需谨记 value_type 是 pair 类型，它的值成员可以修改，但键成员不能修改。
map 类定义的类型
|
map<K, V>::key_type |
在 map 容器中，用做索引的键的类型 |
|
map<K, V>::mapped_type |
在 map 容器中，键所关联的值的类型 |
|
map<K, V>::value_type |
一个 pair 类型，它的 first 元素具有 const map<K, V>::key_type 类型，而 second 元素则为 map<K, V>::mapped_type 类型 |
map<string, int> word_count; // empty map from string to int
map<string, int>::iterator map_it = word_count.begin(); // *map_it is a reference to a pair<const string, int> object
cout << " " << map_it->second; // prints the value of the element
map_it->first = "new key"; // error: key is const
++map_it->second; // ok: we can change value through an iterator
map 类额外定义了两种类型：key_type 和 mapped_type，以获得键或值的类型。
给 map 添加元素
可使用 insert 成员实现；或者，先用下标操作符获取元素，然后给获取的元素赋值。在这两种情况下，一个给定的键只能对应于一个元素这一事实影响了这些操作的行为。 如下编写程序时：
// insert default initialzed element with key Anna; then assign 1 to its value
word_count["Anna"] = 1;
使用下标访问 map 与使用下标访问数组或 vector 的行为截然不同：用下标访问不存在的元素将导致在 map 容器中添加一个新元素，它的键即为该下标值。
下标操作符返回值的使用
通常来说，下标操作符返回左值。它返回的左值是特定键所关联的值。可如下读或写元素：
++word_count["Anna"]; // fetch the element and add one to it
cout << word_count["Anna"]; // fetch the element and print it; prints 2
有别于 vector 或 string 类型，map 下标操作符返回的类型与对 map 迭代器进行解引用获得的类型不相同。显然，map 迭代器返回 value_type 类型的值——包含 const key_type 和 mapped_type 类型成员的 pair 对象；下标操作符则返回一个 mapped_type 类型的值。
对于 map 容器，如果下标所表示的键在容器中不存在，则添加新元素，这一特性可使程序惊人地简练：这段程序创建一个 map 对象，用来记录每个单词出现的次数。
map<string, int> word_count; // empty map from string to int
string word;
while (cin >> word)
++word_count[word];
容器提供的 insert 操作
|
m.insert(e) |
e 是一个用在 m 上的 value_type 类型的值。如果键（e.first）不在 m 中，则插入一个值为 e.second 的新元素；如果该键在 m 中已存在，则保持 m 不变。该函数返回一个 pair 类型对象，包含指向键为 e.first 的元素的 map 迭代器，以及一个 bool 类型的对象，表示是否插入了该元素 |
|
m.insert(beg,end) |
beg 和 end 是标记元素范围的迭代器，其中的元素必须为 m.value_type 类型的键－值对。对于该范围内的所有元素，如果它的键在 m 中不存在，则将该键及其关联的值插入到 m。返回void 类型 |
|
m.insert(iter, e) |
e 是一个用在 m 上的 value_type 类型的值。如果键（e.first）不在 m 中，则创建新元素，并以迭代器 iter 为起点搜索新元素存储的位置。返回一个迭代器，指向 m 中具有给定键的元素 |
以 insert 代替下表运算
插入元素的另一个方法是：直接使用 insert 成员，其语法更紧凑：
word_count.insert(map<string, int>::value_type("Anna", 1));
传递给 insert 的实参相当笨拙。可用两种方法简化：使用 make_pair:
word_count.insert(make_pair("Anna", 1));
或使用 typedef
typedef map<string,int>::value_type valType;
带有一个键－值 pair 形参的 insert 版本将返回一个值：包含一个迭代器和一个 bool 值的 pair 对象，其中迭代器指向 map 中具有相应键的元素，而 bool值则表示是否插入了该元素。如果该键已在容器中，则其关联的值保持不变，返回的 bool 值为 true。在这两种情况下，迭代器都将指向具有给定键的元素。下面是使用 insert 重写的单词统计程序：
map<string, int> word_count; // empty map from string to int
string word;
while (cin >> word)
{
// inserts element with key equal to word and value 1;
// if word already in word_count, insert does nothing
pair<map<string, int>::iterator, bool> ret = word_count.insert(make_pair(word, 1));
if (!ret.second)
// word already in word_count
++ret.first->second;
// increment
counter
对于每个单词，都尝试 insert 它，并将它的值赋 1。
if 语句检测 insert 函数返回值中的 bool 值。如果该值为 false，则表示没有做插入操作，按 word 索引的元素已在word_count 中存在。此时，将该元素所关联的值加 1。
使用下标存在一个很危险的副作用：如果该键不在 map 容器中，那么下标操作会插入一个具有该键的新元素。map 容器提供了两个操作：count 和 find，用于检查某个键是否存在而不会插入该键。
不修改 map 对象的查询操作
|
m.count(k) |
返回 m 中 k 的出现次数 |
|
m.find(k) |
如果 m 容器中存在按 k索引的元素，则返回指向该元素的迭代器。如果不存在，则返回超出末端迭代器 |
对于 map 对象，count 成员的返回值只能是 0 或 1。map 容器只允许一个键对应一个实例，所以 count 可有效地表明一个键是否存在。
而对于 multimaps 容器，count 的返回值将有更多的用途。
如果返回值非 0，则可以使用下标操作符来获取该键所关联的值，而不必担心这样做会在 map 中插入新元素：
if (word_count.count("foobar"))
occurs = word_count["foobar"];
当然，在执行 count 后再使用下标操作符，实际上是对元素作了两次查找。如果希望当元素存在时就使用它，则应该用find 操作。find 操作返回指向元素的迭代器，如果元素不存在，则返回 end 迭代器：
map<string,int>::iterator it = word_count.find("foobar");
if (it != word_count.end())
occurs = it->second;
如果希望当具有指定键的元素存在时，就获取该元素的引用，否则就不在容器中创建新元素，那么应该使用 find。
有一点不同：map 容器的 erase 操作返回 void，而顺序容器的erase 操作则返回一个迭代器，指向被删除元素后面的元素。
从 map 对象中删除元素
|
m.erase(k) |
删除 m 中键为 k 的元素。返回 size_type 类型的值，表示删除的元素个数 |
|
m.erase(p) |
从 m 中删除迭代器 p 所指向的元素。p 必须指向 m 中确实存在的元素，而且不能等于 m.end()。返回 void |
|
m.erase(b,e) |
从 m 中删除一段范围内的元素，该范围由迭代器对 b 和 e 标记。b 和 e 必须标记 m 中的一段有效范围：即 b 和 e 都必须指向 m 中的元素或最后一个元素的下一个位置。而且，b 和 e 要么相等（此时删除的范围为空），要么 b 所指向的元素必须出现在 e 所指向的元素之前。返回 void 类型 |
if (word_count.erase(removal_word))
cout << "ok: " << removal_word << " removed\n";
else
cout << "oops: " << removal_word << " not found!\n";
m.erase(k)函数返回被删除元素的个数。 对于map 容器，该值必然是 0 或 1。如果返回 0，则表示欲删除的元素在 map 不存在。
map 对象的迭代遍历
与其他容器一样，map 同样提供 begin 和 end 运算，以生成用于遍历整个容器的迭代器。例如，可如下将 map 容器 word_count 的内容输出：
map<string, int>::const_iterator map_it = word_count.begin();
// for each element in the map
while (map_it != word_count.end())
{
// print the element key, value pairs
cout << map_it->first << " occurs " << map_it->second << " times" << endl;
++map_it; // increment iterator to denote the next element
}
这个单词统计程序依据字典顺序输出单词。在使用迭代器遍历 map 容器时，迭代器指向的元素按键的升序排列。
set 类型
当只想知道一个值是否存在时，使用 set 容器是最适合的。
两种例外包括：set 不支持下标操作符，而且没有定义 mapped_type 类型。在 set 容器中，value_type 不是 pair 类型，而是与 key_type 相同的类型。它们指的都是 set 中存储的元素类型。这一差别也体现了 set 存储的元素仅仅是键，而没有所关联的值。与 map 一样，set 容器存储的键也必须唯一，而且不能修改。
set 容器的定义和使用
在 set 对象中插入一组元素时，对于每个键，事实上都只添加了一个元素：
vector<int> ivec;
for (vector<int>::size_type i = 0; i != 10; ++i)
{
ivec.push_back(i);
ivec.push_back(i); // duplicate copies of each number
}
// iset holds unique elements from ivec
set<int> iset(ivec.begin(), ivec.end());
cout << ivec.size() << endl; // prints 20
cout << iset.size() << endl; // prints 10
可使用 insert 操作在 set 中添加元素：
set1.insert("the"); // set1 now has one element
set1.insert("and"); // set1 now has two elements
另一种用法是，调用 insert 函数时，提供一对迭代器实参，插入其标记范围内所有的元素。该版本的 insert 函数类似于形参为一对迭代器的构造函数——对于一个键，仅插入一个元素：
iset2.insert(ivec.begin(), ivec.end()); // iset2 has 10 elements
与 map 容器的操作一样，带有一个键参数的 insert 版本返回 pair类型对象，包含一个迭代器和一个 bool 值，迭代器指向拥有该键的元素，而 bool 值表明是否添加了元素。使用迭代器对的insert 版本返回 void 类型。
正如不能修改 map 中元素的键部分一样，set 中的键也为 const。
set<int>::iterator set_it = iset.find(1);
*set_it = 11; // error: keys in a set are read-only
cout << *set_it << endl; // ok: can read the key
删除指定文件中所有的单词（即该文件记录的是排除集）。也即，我们的单词统计程序只对那些不在排除集中的单词进行统计。使用 set 和 map 容器，可以简单而直接地实现该功能：
{
set<string> excluded; // set to hold words we'll ignore
string remove_word;
while (remove_file >> remove_word)
excluded.insert(remove_word);
string word;
while (cin >> word)
// increment counter only if the word is not in excluded
if (!excluded.count(word))
++word_count[word];
}
map 和 set 容器中，一个键只能对应一个实例。而 multiset 和 multimap 类型则允许一个键对应多个实例。 注意到，关联容器 map 和 set 的元素是按顺序存储的。而 multimap 和 multset 也一样。因此，在 multimap 和 multiset 容器中，如果某个键对应多个实例，则这些实例在容器中将相邻存放。 迭代遍历 multimap 或 multiset 容器时，可保证依次返回特定键所关联的所有元素。
基于一个事实——在 multimap 中，同一个键所关联的元素必然相邻存放。
使用 find 和 count 操作
string search_item("Alain de Botton");
// how many entries are there for this author
typedef multimap<string, string>::size_type sz_type;
sz_type entries = authors.count(search_item);
// get iterator to the first entry for this author
multimap<string,string>::iterator iter = authors.find(search_item);
// loop through the number of entries there are for this author
for (sz_type cnt = 0; cnt != entries; ++cnt, ++iter)
cout << iter->second << endl; // print each title
返回迭代器的关联容器操作
|
m.lower_bound(k) |
返回一个迭代器，指向键不小于 k 的第一个元素 |
|
m.upper_bound(k) |
返回一个迭代器，指向键大于 k 的第一个元素 |
|
m.equal_range(k) |
返回一个迭代器的 pair 对象它的 first 成员等价于 m.lower_bound(k)。而second 成员则等价m.upper_bound(k) |
使用这些操作，可如下重写程序：
// beg and end denote range of elements for this author
typedef multimap<string, string>::iterator authors_it;
authors_it beg = authors.lower_bound(search_item), end = authors.upper_bound(search_item);
// loop through the number of entries there are for this author
while (beg != end)
{
cout << beg->second << endl; // print each title
++beg;
}
如果键 search_item 在容器中存在，则使 beg 指向第一个与之匹配的元素。如果容器中没有这样的元素，那么beg 将指向第一个键比 search_item 大的元素。
若该键没有关联的元素，则 lower_bound 和 upper_bound返回相同的迭代器：都指向同一个元素或同时指向 multimap的超出末端位置。它们都指向在保持容器元素顺序的前提下该键应被插入的位置。
如果该键所关联的元素存在，那么 beg 将指向满足条件的元素中的第一个。可对 beg做自增运算遍历拥有该键的所有元素。当迭代器累加至 end 标志时，表示已遍历了所有这些元素。当 beg 等于end 时，表示已访问所有与该键关联的元素。
equal_range 函数返回存储一对迭代器的 pair 对象。如果该值存在，则 pair 对象中的第一个迭代器指向该键关联的第一个实例，第二个迭代器指向该键关联的最后一个实例的下一位置。如果找不到匹配的元素，则 pair 对象中的两个迭代器都将指向此键应该插入的位置。
使用 equal_range 函数再次修改程序：
// pos holds iterators that denote range of elements for this key
pair<authors_it, authors_it> pos = authors.equal_range(search_item);
// loop through the number of entries there are for this author
while (pos.first != pos.second)
{
cout << pos.first->second << endl; // print each title
++pos.first;
}
本程序的 pos.first 等价于前一方法中的 beg，而 pos.second 等价于 end。
小结
关联容器的元素按键排序和访问。关联容器支持通过键高效地查找和读取元素。键的使用，使关联容器区别于顺序容器，顺序容器的元素是根据位置访问的。
map 和 multimap 类型存储的元素是键－值对。它们使用在 utility 头文件中定义的标准库 pair 类，来表示这些键－值对元素。对 map 或 multimap 迭代器进行解引用将获得 pair类型的值。pair 对象的first 成员是一个 const 键，而 second 成员则是该键所关联的值。set 和 multiset 类型则专门用于存储键。在 map 和 set 类型中，一个键只能关联一个元素。而multimap 和 multiset 类型则允许多个元素拥有相同的键。
关联容器共享了顺序容器的许多操作。除此之外，关联容器还定义一些新操作，并对某些顺序容器同样提供的操作重新定义了其含义或返回类型，这些操作的差别体现了关联容器中键的使用。
关联容器的元素可用迭代器访问。标准库保证迭代器按照键的次序访问元素。begin操作将获得拥有最小键的元素，对此迭代器作自增运算则可以按非降序依次访问各个元素。