11.1 使用关联容器

map 是关键字-值对的集合。例如，可以将一个人的名字作为关键字，将其电话号码作为值。我们称这样的数据结构为“将名字映射到电话号码“。map 类型通常被称为关联数组（associative array）。关联数组与“正常”数组类似，不同之处在于其下标不必是整数。我们通过一个关键字而不是位置来查找值。给定一个名字到电话号码的 map，我们可以使用一个人的名字作为下标来获取此人的电话号码。

与之相对，set 就是关键字的简单集合。当只是想知道一个值是否存在时，set 是最有用的。例如，一个企业可以定义一个名为 bad_checks 的 set 来保存那些曾经开过空头支票的人的名字。在接受一张支票之前，可以查询 bad_checks 来检查顾客的名字是否在其中。

使用 map

一个经典的使用关联数组的例子是单词计数程序：

// 统计每个单词在输入中出现的次数
void count_word()
{
	map<string, int> word_count;	// string 到 int 的空 map
	string word;
	while (cin>>word)
	{
		++word_count[word];			// 提取 word 的计数器并将其加一
	}
	for (const auto &w : word_count)// 对 map 中的每个元素
	{
		// 打印结果
		cout << w.first << " occurs " << w.second
			<< ((w.second > 1) ? " times" : " time") << endl;
	}
}

此程序读取输入，报告每个单词出现多少次。

类似顺序容器，关联容器也是模板。为了定义一个 map，我们必须指定关键字和值的类型。在此程序中，map 保存的每个元素中，关键字是 string 类型，值是 int 类型。当对 word_count 进行下标操作时，我们使用一个 string 作为下标，获得与此 string 相关联的 int 类型的计数器。

使用 set

上一个示例程序的一个合理扩展是：忽略常见单词，如 “the”、“and”、"or"等。我们可以使用 set 保存想忽略的单词，只对不出现在集合中的单词统计出现次数。

// 统计每个单词在输入中出现的次数
void count_word1()
{
	map<string, int> word_count;	// string 到 int 的空 map
	set<string> exclude = { "The","But","And","Or","An","A",
						 "the","but","and","or","an","a" };
	string word;
	while (cin >> word)
	{
		// 只统计不在 exclude 中的单词
		if (exclude.find(word) == exclude.end())
		{
			++word_count[word];			// 获取 word 的计数器并将其加一
		}	
	}
	for (const auto &w : word_count)// 对 map 中的每个元素
	{
		// 打印结果
		cout << w.first << " occurs " << w.second
			<< ((w.second > 1) ? " times" : " time") << endl;
	}
}

与其他容器类似，set 也是模板。为了定义一个 set ，必须指明其元素类型，本例中是 string。与顺序容器类似，可以对一个关联容器的元素进行列表初始化（9.2.4节）。集合 exclude 保存了 12 个我们想忽略的单词。

此程序与前一个程序的重要不同是，在统计每个单词出现次数之前，我们检查单词是否在忽略集合中，这是在 if 语句中完成的：

if (exclude.find(word) == exclude.end())

find 调用返回一个迭代器。如果给定关键字在 set 中，迭代器指向该关键字。否则，find 返回尾后迭代器。在此程序中，仅当 word 不在 exclude 中时我们才更新 word 的计数器。

11.1 节练习

练习 11.1：描述 map 和 vector 的不同。

两类容器的根本在于，顺序容器中的元素是”顺序“ 存储的（链表容器中的元素虽然不是在内存中”连续“存储的，但仍然是按”顺序“存储的）。理解”顺序“ 的关键，是理解容器支持的操作形式以及效率。

对于 vector 这样的顺序容器，元素在其中按顺序存储，每个元素有唯一对应的位置编号，所有操作都是按编号（位置）进行的。例如，获取元素（头、尾、用下标获取任意位置）、插入删除元素（头、尾、任意位置）、遍历元素（按元素位置顺序逐一访问）。底层的数据结构是数组、链表，简单但已能保证上述操作的高效。而对于依赖值的元素访问，例如查找（搜索）给定值（find），在这种数据结构上的实现是要通过遍历完成的，效率不佳。

而 map 这种关联容器，就是为了高效实现“按值访问元素”这类操作而设计的。为了达到这一目的，容器 中的元素是按关键字存储的，关键字值与元素数据建立起对应关系，这就是“关联”的含义。底层数据结构是红黑数、哈希表等，可高效实现按关键字值查找、添加、删除等操作。

练习 11.2：分别给出最适合使用 list、vector、deque、map 以及 set 的例子。

若元素很小（例如 int ），大致数量预先可知，在程序运行过程中不会剧烈变化。大部分情况下只在末尾添加或删除需要频繁访问任意位置的元素，则 vector 可带来最高的效率。若需频繁在头部和尾部添加或删除元素，则 deque 是最好的选择。

如果元素较大（如大的类对象），数量预先不知道，或是程序运行过程中频繁变化，对元素的访问更多是顺序访问全部或很多元素，则 list 很适合。

map 很适合对一些对象按它们的某个特征进行访问的情形。典型的例如按学生的名字来查询学生信息，即可将学生名字作为关键字，将学生信息作为元素值，保存在 map 中。

set，顾名思义，就是集合类型。当需要保存特定的值集合——通常满足/不满足某种要求的值集合，用 set 最方便。

// 练习 11.3：编写你自己的单词计数程序
void count_word()
{
	map<string, int> word_count;	// string 到 int 的空 map
	string word;
	while (cin >> word)
	{
		++word_count[word];			// 提取 word 的计数器并将其加一
	}
	for (const auto &w : word_count)// 对 map 中的每个元素
	{
		// 打印结果
		cout << w.first << " 出现了 " << w.second
			<< " 次" << endl;
	}
}

// 练习 11.4：扩展你的程序，忽略大小写和标点。例如，“example."、"example,"和”Example"应该递增相同的计数器。

// 编写函数 trans，将单词中的标点去掉，将大写转换为小写
string &trans(string &s)
{
	for (int p = 0; p < s.size(); p++)
	{
		if (s[p] >= 'A' && s[p] <= 'Z')
		{
			s[p] -= ('A' - 'a');
		}
		else if (s[p] == ',' || s[p] == '.')
		{
			s.erase(p, 1);
		}
	}
	return s;
}
void count_word1()
{
	map<string, int> word_count;	// string 到 int 的空 map

	string word;
	while (cin >> word)
	{
		++word_count[trans(word)];			// 获取 word 的计数器并将其加一
	}
	for (const auto &w : word_count)// 对 map 中的每个元素
	{
		// 打印结果
		cout << w.first << " 出现了 " << w.second
			<< " 次" << endl;
	}
}

11.2 关联容器概述

关联容器（有序的和无序的）都支持9.2节中介绍的普通容器操作。关联容器不支持顺序容器的位置相关的操作，例如 push_front 或 push_back。原因是关联容器中元素是根据关键字存储的，这些操作对关联容器没有意义。而且，关联容器也不支持构造函数或插入操作这些接受一个元素值和一个数量值的操作。

除了与顺序容器相同的操作外，关联容器还支持一些顺序容器不支持的操作。此外，无序容器还提供一些用来调整哈希性能的操作。

关联容器的迭代器都是双向的。

11.2.1 定义关联容器

如前所示，当定义一个 map 时，必须既指明关键字类型又指明值类型；而定义一个 set 时，只需指明关键字类型，因为 set 中没有值。每个关联容器都定义了一个默认构造函数，它创建一个指定类型的空容器。在新标准下，我们也可以对关联容器进行值初始化。

	map<string, int> words_count;	// 空容器
	// 列表初始化
	set<string> exclude = { "the","but","or","an","a",
							"The","But","And","Or","An","A"};
	// 三个元素；autuors 将姓映射为名
	map<string, string> authors = { {"Joyce","James"},
								{"Austen","Jane"},
								{"Dickens","Charles"} };

与以往一样，初始化器必须能转换为容器中元素的类型。对于 set，元素类型就是关键字类型。

当初始化一个 map 时，必须提供关键字类型和值类型。我们将每个关键字-值对包围在花括号中：

{key,value}

来指出它们一起构成了 map 中的一个元素。在每个花括号中，关键字是第一个元素，值是第二个。因此 authors 将姓映射到名，初始化后它包含三个元素。

初始化 multimap 和 multiset

一个 map 或 set 中的关键字必须是唯一的，即，对于一个给定的关键字，只能有一个元素的关键字等于它。容器 multimap 和 multiset 没有此限制，它们都允许多个元素具有相同的关键字。例如，在我们用来统计单词数量的 map 中，每个单词只能有一个元素。另一方面，在一个词典中，一个特定单词则可具有多个与之关联的词义。

下面的例子展示了具有唯一关键字的容器与允许重复关键字的容器之间的区别。首先，我们将创建一个名为 ivec 的保存 int 的 vector，它包含 20 个元素：0 到 9 每个整数有两个拷贝。我们将使用此 vector 初始化一个 set 和一个 multiset。

	// 定义一个有 20 个元素的 vector，保存 0 到 9 每个整数的两个拷贝
	vector<int> ivec;
	for (vector<int>::size_type i = 0; i != 10; ++i)
	{
		ivec.push_back(i);
		ivec.push_back(i);	//每个数重复保存一次
	}

	// iset 包含来自 ivec 的不重复的元素；miset 包含所有元素 20 个元素
	set<int> iset(ivec.cbegin(), ivec.cend());
	multiset<int> miset(ivec.cbegin(), ivec.cend());
	cout << ivec.size() << endl;		// 打印出 20
	cout << iset.size() << endl;		// 打印出 10
	cout << miset.size() << endl;		// 打印出 20

11.2.1 节练习

练习 11.5：解释 map 和 set 的区别。你如何选择使用哪个？

当需要查找给定值所对应的数据时，应使用 map，其中保存的是 <关键字,值>对，按关键字访问值。

如果只需判定给定值是否存在时，应使用 set，它是简单的值的集合。

练习 11.6：解释 set 和 list 的差别。你如何选择使用哪个？

两者都可以保存元素集合。

如果只需要顺序访问这些元素，或是按位置访问元素，那么应该使用 list。如果需要快速判断是否有元素等于给定值，则应使用 set。

// 练习 11.7：定义一个 map，关键字是家庭的姓，值是一个 vector，保存家中孩子（们）
// 的名。编写代码，实现添加新的家庭以及向已有家庭中添加新的孩子。
void add_family(map<string, vector<string>> &families, const string &family)
{
	if (families.find(family) == families.end())
		families[family] = vector<string>();
}
void add_child(map<string, vector<string>> &families, const string &family,const string &child)
{
	families[family].push_back(child);
}
void test_family()
{
	map<string, vector<string>> families;

	add_family(families, "张");
	add_child(families, "张","强");
	add_child(families, "张", "刚");
	add_child(families, "王", "五");
	add_family(families, "王");

	for (auto f : families)
	{
		cout << f.first << "家的孩子： ";
		for (auto c : f.second)
		{
			cout << c << " ";
		}
		cout << endl;
	}
}

// 练习 11.8：编写一个程序，在一个 vector 而不是一个 set 中保存不重复的单词。使用 set 的优点是什么？
string &trans(string &s)
{
	for (int p = 0; p < s.size(); p++)
	{
		if (s[p] >= 'A' && s[p] <= 'Z')
			s[p] -= ('A' - 'a');
		else if (s[p] == ',' || s[p] == '.')
			s.erase(p, 1);
	}
}
// 使用 vector
void save_words_toV()
{
	vector<string> unique_word;
	string word;
	while (cin >> word)
	{
		trans(word);
		if (find(unique_word.begin(), unique_word.end(), word) == unique_word.end())
			unique_word.push_back(word);	//  添加不重复单词
	}
	for (const auto &w : unique_word)		// 打印不重复单词
	{
		// 打印结果
		cout << w << " ";
	}
	cout << endl;
}

// 使用 set
void save_words_toSet()
{
	set<string> unique_word;
	string word;
	while (cin >> word)
	{
		trans(word);
		unique_word.insert(word);			//  添加不重复单词
	}
	for (const auto &w : unique_word)		// 打印不重复单词
	{
		// 打印结果
		cout << w << " ";
	}
	cout << endl;
}

使用 set 可以不用编写检查重复单词的代码。vector 可以保持单词的输入顺序，而 set 则不能，遍历 set，元素是按值的升序被遍历的。

11.2.2 关键字类型的要求

关联容器对其关键字类型有一些限制。对于有序容器——map、multimap、set 以及 multiset，关键字类型必须定义元素比较的方法。默认情况下，标准库使用关键字类型的 < 运算符来比较两个关键字。在集合类型中，关键字类型就是元素类型；在映射类型中，关键字类型是元素的第一部分的类型。

传递给排序算法的可调用对象必须满足与关联容器中关键字一样的类型要求。

有序容器的关键字类型

可以向一个算法提供我们自己定义的比较操作（10.3节），与之类似，也可以提供自己定义的操作来代替关键字上的 < 运算符。所提供的操作必须在关键字类型上定义一个严格弱序(strict weak ordering)。可以将严格弱序看作“小于等于”。它必须具备如下基本性质：

• 两个关键字不能同时“小于等于”对方；如果 k1 “小于等于” k2，那么 k2 绝不能“小于等于” k1。
• 如果 k1 “小于等于” k2，且 k2 “小于等于” k3，那么 k1 必须 “小于等于” k3。
• 如果存在两个关键字，任何一个都不“小于等于” 另一个，那么我们称这两个关键字是“等价”的。如果 k1 “等价于” k2，且 k2 “等价于” k3，那么 k1 必须“等价于” k3。

如果两个关键字是等价的（即，任何一个都不“小于等于”另一个），那么容器将它们视作相等来处理。当用作 map 的关键字时，只能有一个元素与这两个关键字关联，我们可以用两者中任意一个来访问对应的值。

使用关键字类型的比较元素

用来组织一个容器中元素的操作也是该容器类型的一部分。为了指定使用自定义的操作，必须在定义关联容器类型时提供此操作的类型。如前所述，用尖括号指出要定义哪种类型的容器，自定义的操作类型必须在尖括号中紧跟着元素类型给出。

在尖括号中出现的每个类型，就仅仅是一个类型而已。当我们创建一个容器（对象）时，才会以构造函数参数的形式提供真正的比较操作（其类型必须与在尖括号中指定的类型相吻合）。

例如，我们不能直接定义一个 Sales_data 的 multiset，因为 Sales_data 没有 < 运算符。但是，可以用 compareIsbn 函数来定义一个 multiset。此函数在 Sales_data 对象的 ISBN 成员上定义了一个严格弱序。函数 compareIsbn 应该像这样定义

bool compareIsbn(const Sales_data &lhs,const Sales_data &rhs)
{
    return lhs.isbn() < rhs.isbn();
}

为了使用自己定义的操作，在定义 multiset 时我们必须提供两个类型：关键字类型 Sales_data，以及比较操作类型——应该是一种函数指针类型（6.7节），可以指向 compareIsbn。当定义此容器类型的对象时，需要提供相应使用的操作的指针。在本例中，我们提供一个指向 compareIsbn 的指针

// bookstore 中多条记录可以有相同的 ISBN 
// bookstore 中的元素以 ISBN 的顺序进行排列
multiset<Sales_data, decltype(compareIsbn)*>
    bookstore(compareIsbn);

此处，我们使用 decltype 来指出自定义操作的类型。记住，当用 decltype 来获得一个函数指针类型时，必须加上一个 * 来指出我们要使用一个给定函数类型的指针。用 compareIsbn 来初始化 bookstore 对象，这表示当我们向 bookstore 添加元素时，通过调用 compareIsbn 来为这些元素排序。即，bookstore 中的元素将按它们的 ISBN 成员的值排序。可以用 compareIsbn 代替 &compareIsbn 作为构造函数的参数，因为当我们使用一个函数的名字时，在需要的情况下它会自动转化为一个指针。当然，使用 &compareIsbn 的效果也是一样的。

11.2.2 节练习

// 练习 11.9：定义一个 map，将单词与一个行号的 list 关联，list 中保存的是单词所出现的行号。
map<string, list<int>>word_lineno;
string &trans(string &s)
{
	for (int p = 0; p < s.size(); p++)
	{
		if (s[p] >= 'A' && s[p] <= 'Z')
			s[p] -= ('A' - 'a');
		else if (s[p] == ',' || s[p] == '.')
			s.erase(p, 1);
	}
}
void save_word()
{
	map<string, list<int>>word_lineno;	//单词到行号的映射
	string line;
	string word;
	int lineno = 0;
	ifstream in;
	if (!in)
	{
		cout << "打开输入文件失败！" << endl;
	}
	while (getline(in, line))	//读取一行
	{
		lineno++;				//行号递增
		istringstream l_in(line);//构造字符串流，读取单词
		while (l_in >> word)
		{
			trans(word);
			word_lineno[word].push_back(lineno);	//添加行号
		}
	}
	// 打印单词行号
	for (const auto &w : word_lineno)
	{
		cout << w.first << "所在行： ";
		for (const auto &i : w.second)
			cout << i << " ";
		cout << endl;
	}
}

练习 11.10：可以定义一个 vector::iterator 到 int 的 map 吗？list::iterator 到 int 的 map 呢？对于两种情况，如果不能，解释为什么

由于有序容器要求关键字类型必须支持比较操作 < ，因此

map<vector<int>::iterator, int> m1;

是可以的，因为 vector 的迭代器支持比较操作。而

map<list<int>::iterator,int> m2;

是不行的，因为 list 的元素不是连续存储，其迭代器不支持比较操作。

练习 11.11：不使用 decltype 重新定义 bookstore。

// 首先用typedef 定义与 compareIsbn 相容的函数指针类型，然后用此类型声明 multiset 即可。
typedef bool (*pf)(const Sales_data &, const Sales_data &)
multiset<Sales_data,pf> bookstore(compareIsbn);

11.2.3 pair 类型

在介绍关联容器的操作之前，我们需要了解名为 pair 的标准库类型，它定义在头文件 utility 中。

一个 pair 保存两个数据成员。类似容器，pair 是一个用来生成特定类型的模板。当创建一个 pair 时，我们必须提供两个类型名，pair 的数据成员将具有对应的类型。两个类型不要求一样：

pair<string, string> anon;			// 保存两个 string
pair<string, size_t> word_count;	// 保存一个 string 和一个 size_t
pair<string, vector<int>> line;		// 保存 string 和 vector<int>

pair 的默认构造函数对数据成员进行值初始化（参见3.3.1节）。因此，anon 是一个包含两个空 string 的 pair，line 保存一个空 string 和一个空 vector。word_count 中的 size_t 成员值为 0，而 string 成员被初始化为空。

我们也可以为每个成员提供初始化器：

pair<string, string> author{"James","Joyce"};

这条语句创建一个名为 author 的 pair ，两个成员被初始化 为"James"和"Joyce"。

与其他标准库类型不同，pair 的数据成员是 public 的（7.2节）。两个分别命名为 first 和 second。我们用普通的额乘以访问符号（1.5.2节）来访问它们，例如，在之前的单词计数程序的输出语句中我们就是这么做的：

// 打印结果
cout<< w.first << " occurs " << w.second
	<<((w.second > 1) ? "times" : "time") << endl;

此处，w 是指向 map 中某个元素的引用。map 的元素是 pair。下表列出了 pair 上的操作。

// 一个返回 pair 的函数
pair<string,int> process(vector<string> &v)
{
	// 处理 v
	if (!v.empty())
	{
		return { v.back(),v.back().size() };	//列表初始化
	}
	else
	{
		return pair<string, int>();				// 隐式构造返回值
	}
}

	if (!v.empty())
	{
		return pair<string, int>(v.back(),v.back().size());	
	}

	if (!v.empty())
	{
		return make_pair(v.back(),v.back().size());	
	}

// 练习 11.12：编写程序，读入 string 和 int 的序列，将每个 string 和 int 存入一个 pair 中，pair 保存在一个 vector 中。
void save_to_pair()
{
	string s;
	int i;
	vector<pair<string, int>> v;
	while (cin >> s && cin >> i)
	{
		v.push_back(pair<string, int>(s, i));;
	}
	// 打印数据
	for (const auto &d : v)
		cout << d.first << " " << d.second << endl;
}

// 练习 11.13：编写上一题程序的三个版本，分别采用不同的方法创建 pair。解释你认为哪种形式最易于编写和理解，为什么？
void save_to_pair1()
{
	string s;
	int i;
	vector<pair<string, int>> v;
	while (cin >> s && cin >> i)
	{
		//第一种	默认初始化
		v.push_back(pair<string, int>(s, i));
		//第二种	列表初始化
		v.push_back({ s,i });
		//第三种
		v.push_back(make_pair(s, i));

	}
	// 打印数据
	for (const auto &d : v)
		cout << d.first << " " << d.second << endl;
}

// 练习 11.14： 扩展 11.2.1 中编写的孩子姓到名的 map，添加一个 pair 的 vector，保存孩子的名和生日。
void add_family(map<string, vector<pair<string, string>>>  &families, const string &family)
{
	families[family];
}
void add_child(map<string, vector<pair<string, string>>> &families, const string &family,const string &child,const string &birthday)
{
	families[family].push_back({ child,birthday });
}
void test_family()
{
	// vector 中保存 pair
	map<string, vector<pair<string, string>>> families;

	add_family(families, "张");
	add_child(families, "张","强","2000-1-1");
	add_child(families, "张", "刚","1980-2-2");
	add_child(families, "王", "五","1990-1-1");
	add_family(families, "王");

	for (auto f : families)
	{
		cout << f.first << "家的孩子： ";
		for (auto c : f.second)
		{
			cout << c.first << " （生日" << c.second << "）， ";
		}
		cout << endl;
	}
}

	set<string>::value_type v1;		 // v1 是一个 string
	set<string>::key_type v2;		 // v2 是一个 string
	map<string, int>::value_type v3; // v3 是一个 pair<const string, int>
	map<string, int>::key_type v4;	 // v4 是一个 string
	map<string, int>::mapped_type v5;// v5 是一个 int

	map<string, int> word_count;
	// 获得指向 word_count 中一个元素的迭代器
	auto map_it = word_count.begin();
	// *map_it 是指向一个 pair<const string, size_t> 对象的引用
	cout << map_it->first;			// 打印此元素的关键字
	cout << " " << map_it->second;	// 打印此元素的值
	map_it->first = "new key";		// 错误：关键字是 const 的
	++map_it->second;				// 正确：我们可以通过迭代器改变元素

	set<int> iset = { 0,1,2,3,4,5,6,7,8,9 };
	set<int>::iterator set_it = iset.begin();
	if (set_it != iset.end())
	{
		*set_it = 42;				//错误： set 中的关键字是只读的
		cout << *set_it << endl;	//正确：可以读关键字
	}

	map<string, int> word_count;
	// 获得指向 word_count 中一个元素的迭代器
	auto map_it = word_count.cbegin();
	// 比较当前迭代器和尾后迭代器
	while (map_it != word_count.cend())
	{
		// 解引用迭代器，打印关键字-值对
		cout << map_it->first << " occurs "
			<< map_it->second << "times" << endl;
		++map_it;	//递增迭代器，移动到下一个元素
	}

// 练习 11.16：使用一个 map 迭代器编写一个表达式，将一个值赋予一个元素。
void map_it()
{
	map<string, int> mp;
	auto it = mp.begin();
	it->second = 0;
}

// 练习 11.17：假定 c 是一个 string 的 multiset，v 是一个 string 的 vector，
// 解释下面的调用。指出每个调用是否合法：
void test()
{
	multiset<string> c;
	vector<string> v;
	copy(v.begin(), v.end(), inserter(c, c.end()));
	copy(v.begin(), v.end(), back_inserter(c));
	copy(c.begin(), c.end(), inserter(v, v.end()));
	copy(c.begin(), c.end(), back_inserter(v));
}

typedef bool (*pf)(const Sales_data &,const Sales_data &);
multiset<Sales_data, pf> bookstore(compareIsbn);
...
pair<const Sales_data, pf>::iterator it = bookstore.begin();

vector<int> ivec={2,4,6,8,2,4,6,8};
	set<int> set2;								// 空集合
	set2.insert(ivec.cbegin(), ivec.cend());	// set2 有 4 个元素
	cout << endl;
	set2.insert({ 1,3,5,7,1,3,5,7 });			// set2 现在有 8 个元素

	map<string, int> word_count;
	string word;
	// 向 word_count 插入 word 的 4 种方法
	word_count.insert({ word,1 });
	word_count.insert(make_pair(word, 1));
	word_count.insert(pair<string, int>(word, 1));
	word_count.insert(map<string, int>::value_type(word, 1));

map<string, int>::value_type(s, 1)

// 单词计数程序
void word_count()
{
	// 统计每个单词在输入中出现次数的一种更烦琐的方法
	map<string, int>word_count;
	string word;
	while (cin >> word)
	{
		// 插入一个元素，关键字等于 word，值为 1；
		// 若 word 已在 word_count 中，insert 什么也不做
		auto ret = word_count.insert({ word,1 });
		if (!ret.second)			// word 已在 word_count 中
		{
			++ret.first->second;	// 递增计数器
		}
	}
}

++((ret.first)->second);	// 等价表达式

	multimap<string, string> authors;
	// 插入第一个元素，关键字为 Barth,Jhon
	authors.insert({ "Barth,Jhon","Sot-Weed Factor" });
	// 正确：添加第二个元素，关键字也是 Barth,Jhon
	authors.insert({ "Barth,Jhon","Lost in the Funhouse" });
	for (auto value : authors)
	{
		cout << value.first << " " << value.second << endl;
	}
}

// 统计每个单词在输入中出现的次数
void count_word()
{
	map<string, int> word_count;	// string 到 int 的空 map
	string word;
	while (cin>>word)
	{
		++word_count[word];			// 提取 word 的计数器并将其加一
	}
	for (const auto &w : word_count)// 对 map 中的每个元素
	{
		// 打印结果
		cout << w.first << " occurs " << w.second
			<< ((w.second > 1) ? " times" : " time") << endl;
	}
}

while (cin >> word)
{
	++word_count.insert({word,0}).first->seond;
}

// 练习 11.23:11.2.1 节练习中的 map 以孩子的姓为关键字，保存他们的名的 vector，用 multimap 重写此 map。
void add_child(multimap<string, string> &families, const string &family, const string &child)
{
	families.insert({ family,child });

}
void test_family()
{
	multimap<string, string>  families;
	add_child(families, "张", "强");
	add_child(families, "张", "刚");
	add_child(families, "王", "五");
	for (auto f : families)
	{
		cout << f.first << "家的孩子： " << f.second << endl;
	}
}
i

	// 删除一个关键字，返回删除的元素数量
	if (word_count.erase(remove_word))
		cout << "OK: " << remove_word << " removed\n";
	else cout << "oops: " << remove_word << " not found!\n";

auto cnt = authors.erase("Barth,Jhon");

map<string, int> word_count;
// 插入一个关键字为 Anna 的元素，关联值进行值初始化；然后将 1 赋予它
word_count["Anna"] = 1;

cout<<word_count["Anna"];// 用 Anna 作为下标提取元素；会打印出 1
++word_count["Anna"];	// 提取元素，将其增1
cout<<word_count["Anna"];//提取元素并打印它；会打印出 2

map<int, int> m;
m[0]=1;

vector<int> v;
v[0]=1;

	set<int> iset = { 0,1,2,3,4,5,6,7,8,9 };
	iset.find(1);		// 返回一个迭代器，指向 key == 1 的元素
	iset.find(11);		// 返回一个迭代器，其值等于 iset.end()
	iset.count(1);		// 返回 1
	iset.count(0);		// 返回 0

if(word_count.find("floor")==word_count.end())
	cout<<"floor is not in the map"<<endl;

	multimap<string, string> authors;
	// 插入第一个元素，关键字为 Barth,Jhon
	authors.insert({ "Barth,Jhon","Sot-Weed Factor" });
	// 正确：添加第二个元素，关键字也是 Barth,Jhon
	authors.insert({ "Barth,Jhon","Lost in the Funhouse" });	
	// 打印一个特定作者的所有著作
	string search_item("Alain de Botton");		// 要查找的作者
	auto entries = authors.count(search_item);	// 元素的数量
	auto iter = authors.find(search_item);		// 此作者的第一本书
	// 用一个循环查找此作者的所有著作
	while (entries)
	{
		cout << iter->second << endl;			// 打印每个题目
		++iter;									// 前进到下一本书
		--entries;								// 记录已经打印了多少本书
	}

	// 使用 lower_bound 和 upper_bound 重写前面的程序
	// beg 和 end 表示对应此作者的元素的范围
	for (auto beg = authors.lower_bound(search_item),
		end = authors.upper_bound(search_item);
		beg != end; ++beg)
		cout << beg->second << endl;	// 打印每个题目

	// pos 保存迭代器对，表示与关键字匹配的元素范围
	for (auto pos = authors.equal_range(search_item); pos.first != pos.second; ++pos.first)
		cout << pos.first->second << endl;	// 打印每个题目

// 练习 11.28：对一个 string 到 int 的 vector 的 map，定义并初始化一个变量来保存在其上并调用 find 所返回的结果
map<string, vector<int>> m;
// 保存 find 返回结果的变量
map<string, vector<int>>::iterator iter;

// 练习 11.31：编写程序，定义一个作者及其作品的 multimap。使用 find 在 multimap 中查找一个元素并
// erase 删除它。确保你的程序在元素不在 map 中时也能正常运行。
void remove_author(multimap<string, string> &books, const string &author)
{
	auto pos = books.equal_range(author);
	if (pos.first == pos.second)
	{
		cout << "没有 " << author << " 这个作者" << endl;
	}
	else
	{
		books.erase(pos.first, pos.second);
	}
}

// 练习 11.32：使用上一题定义的 multimap 编写一个程序，按字典序打印作者列表和他们的作品
void print_books(multimap<string, string> &books)
{
	cout << "当前书目包括： " << endl;
	for (auto &book : books)	// 遍历所有书籍，打印之
		cout << book.first << ", 《" << book.second << "》" << endl;
	cout << endl;
}

brb be right back
k okay?
y why
r are
u you
pic picture
thk thanks!
18r later

where r u
y dont u send me a pic
k thk 18r

where are you
why dont you send me a picture
okay? thanks! later

void word_transform(ifstream &map_file, ifstream &input)
{
	auto trans_map = bulidMap(map_file);		// 保存转换规则
	string text;								// 保存输入中的每一行
	while (getline(input, text))				// 读取一行输入
	{
		istringstream stream(text);				// 读取每个单词
		string word;
		bool firstword = true;					// 控制是否打印空格
		while (stream >> word)
		{
			if (firstword)
				firstword = false;
			else
				cout << " ";					// 在单词间打印出一个空格
			// transform 返回它的第一个参数或其转换之后的形式
			cout << transform(word, trans_map);	//打印输出
		}
		cout << endl;							// 完成一行的转换
	}
}

map<string,string> bulidMap(ifstream &map_file)
{
	map<string, string> trans_map;			// 保存转换规则
	string key;								// 要转换的单词
	string value;							// 替换后的内容
	// 读取第一个单词存入 key 中，行中剩余内容存入 value
	while (map_file >> key && getline(map_file, value))
	{
		if (value.size() > 1)				// 检查是否有转换规则
		{
			trans_map[key] = value.substr(1);// 跳过前导空格
		}
		else
		{
			throw runtime_error("no rule for " + key);
		}
	}
	return trans_map;
}

const string& transform(const string &s, const map<string, string> &m)
{
	// 实际的转换工作；此部分是程序的核心
	auto map_it = m.find(s);
	// 如果单词在转换规则 map 中
	if (map_it != m.cend())
	{
		return map_it->second;		// 使用替换短语
	}
	else
	{
		return s;					// 否则返回原 string
	}
}

map<string,string> bulidMap(ifstream &map_file)
{
	map<string, string> trans_map;			// 保存转换规则
	string key;								// 要转换的单词
	string value;							// 替换后的内容
	// 读取第一个单词存入 key 中，行中剩余内容存入 value
	while (map_file >> key && getline(map_file, value))
	{
		if (value.size() > 1)				// 检查是否有转换规则
		{
			trans_map[key] = value.substr(1);// 跳过前导空格
		}
		else
		{
			throw runtime_error("no rule for " + key);
		}
	}
	return trans_map;
}
const string& transform(const string &s, const map<string, string> &m)
{
	// 实际的转换工作；此部分是程序的核心
	auto map_it = m.find(s);
	// 如果单词在转换规则 map 中
	if (map_it != m.cend())
	{
		return map_it->second;		// 使用替换短语
	}
	else
	{
		return s;					// 否则返回原 string
	}
}
void word_transform(ifstream &map_file, ifstream &input)
{
	auto trans_map = bulidMap(map_file);		// 保存转换规则
	string text;								// 保存输入中的每一行
	while (getline(input, text))				// 读取一行输入
	{
		istringstream stream(text);				// 读取每个单词
		string word;
		bool firstword = true;					// 控制是否打印空格
		while (stream >> word)
		{
			if (firstword)
				firstword = false;
			else
				cout << " ";					// 在单词间打印出一个空格
			// transform 返回它的第一个参数或其转换之后的形式
			cout << transform(word, trans_map);	//打印输出
		}
		cout << endl;							// 完成一行的转换
	}
}

trans_map[key] = value.substr(1);
改为 trans_map({key, value.substr(1)})

练习 11.34：如果你将 transform 函数中的 find 替换为下标运算符，会发生什么情况？

<span style="background:#eef0f4;">find 仅会查找给定关键字在容器中是否出现，若容器中不存在给定关键字，它返回尾后迭代器。当关键字存在时，下标运算符的行为与 find 类似，但当关键字不存在时，它会构造一个pair （进行值初始化），将其插入到容器中。对于单词转换程序，这会将不存在的内容插入到输出文本中，这显然不是我们所期望的。</span>

练习 11.35：在 buildMap 中，如果进行如下改写，会有什么效果？

<span style="background:#eef0f4;">当 map 中没有给定关键字时，insert 操作与下标操作+赋值操作的效果类似，都是将关键字和值的 pair 添加到 map 中。</span>

<span style="background:#eef0f4;">但当 map 中已有给定关键字，也就是新的转换规则与上一条已有规则要转换同一个单词时，两者的行为是不同的。</span><span style="background:#d4e9d5;">下标操作会获得具有该关键字的元素（也就是已有规则）的值，并将新读入的值赋予它，也就是用心读入的规则覆盖了容器中的已有规则。</span><span style="background:#dad5e9;">但 insert 操作遇到关键字已存在的情况，则不会改变容器内容，而是返回一个值指出插入失败。</span><span style="background:#eef0f4;">因此，当规则文件中存在多条规则转换相同单词时，下标+赋值的版本最终会用最后一条规则进行文本转换，而 insert 版本则会用第一条规则进行文本转换。</span>

练习 11.36：我们的程序并没有检查输入文件的合法性。特别是，它假设转换规则文件中的规则都是有意义的。如果文件中的某一行包含一个关键字、一个空格，然后就结束了，会发生什么？预测程序的行为并进行验证，再与你的程序进行比较。

[外链图片转存中...(img-2s7XEuJ5-1642757185254)]

## 11.4 无序容器