C++ Primer 第十章 关联容器
关联容器和顺序容器的本质差别在于:关联容器通过键(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操作将获得拥有最小键的元素,对此迭代器作自增运算则可以按非降序依次访问各个元素。