C++ Primer学习笔记2--c++ 关联容器

1.两个基本的关联容器类型是 map set。

map 元素以键-值(key-value)对的形式组织:键用作元素在 map
中的索引,而值则表示所存储和读取的数据。

set 仅包含一个键,并有效地支持关于某个键是否存在的查询。

如果希望有效地存储不同值的集合,那么使用 set
容器比较合 适,

而 map
容器则更适用于需要存储(乃至修改)每个键所关联的值的情况。

在做某种文本处理时,可使用 set
保存要忽略的单词。

而字典则是 map
的一种 很好的应用:单词本身是键,而它的解释说明则是值。

不允许为同一个键
添加第二个元素。如果一个键必须对应多个实例,则需使用 multimap
或 multi set,这两种类型允许多个元素拥有相同的键。

2.<utility> pair

(1) pair<T1, T2> p1;

创建一个空的 pair
对象,它的两个元素分别是 T1
和 T2 类型,采用值初始化

eg:

pair<string, string> anon; // holds two strings

pair<string, int> word_count; // holds a string and an int

pair<string, vector<int> > line; // holds string and vector<int>

如果在创建 pair
对象时不提供初始化式,则调用默认构造函数对其成员采
用值初始化。

(2)pair<T1, T2> p1(v1, v2);

创建一个 pair
对象,它的两个元素分别是 T1
和 T2 ,其
中 first 成员初始化为 v1,而 second
成员初始化为 v2

pair<string, string> author("James", "Joyce");

利用 typedef
简化其声明:

typedef pair<string, string> Author;

Author proust("Marcel", "Proust");

Author joyce("James", "Joyce");

(3) make_pair(v1,v2)

以 v1
和 v2 值创建一个新 pair
对象,其元素类型分别是 v1
和 v2 的类型

pair<int, int> p1(1,2);

pair<int, int> p2;

p2 = make_pair(1, 2);

(4)简单操作

p1 < p2

两个 pair
对象之间的小于运算,其定义遵循字典次序:如
果 p1.first < p2.first
或者 !(p2.first < p1.first) && p1.second < p2.second,则返回 true

p1 == p2

如果两个 pair
对象的 first 和 second
成员依次相等, 则这两个对象相等。该运算使用其元素的 ==
操作符

与其他标准库类型不同,对于 pair
类,可以直接访问其数据成员:其成员
都是仅有的,分别命名为 first
和 second。

p.first

返回 p
中名为 first 的(公有)数据成员

p.second

返回 p
的名为 second 的(公有)数据成员

3.关联容器

关联容器不提供 front、 push_front、 pop_front、back、push_back
以及 pop_back
操作。

在迭代遍历关联容器时,我们可确保按键的顺序的访问元素,而与元素在容器中的存放位置完全无关。

(1)map

#include <map>

在定义 map
对象时,必须分
别指明键和值的类型(value type)

map<string, int>word_count;

构造函数

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。

例如,word_count
数组的 value_type 为 pair<const string, int>
类型。

3种类型

(1) map<K,V>::key_type 在 map
容器中,用做索引的键的类型

(2)map<K, V>::mapped_type 在 map
容器中,键所关联的值的类型

(3)map<K,V>::value_type

一个 pair
类型,它的 first
元素具有 const map<K, V>::key_type
类型,而 second
元素则为 map<K, V>::mapped_type 类型

对迭代器进行解引用将获得一个 pair
对象,它的 first
成员存放键,为 const,而 second
成员则存放值。

（2）给map添加元素

a.使用下标

map <string, int> word_count; // empty map

// insert default initialzed element with key Anna; then assign 1 to its value

word_count["Anna"] = 1;

map 迭代器返回 value_type
类型的值——包含 const key_type
和 mapped_type 类型成员的 pair
对象;下标操作符则返回一个 mapped_type
类
型的值。

---------------------

*map下标编程的意思*

对于 map
容器,如果下标所表示的键在容器中不存在,则添加新元素

map<string, int> word_count;

string word;

while (cin >> word)

++word_count[word];

这段程序创建一个 map
对象,用来记录每个单词出现的次数。

while 循环
每次从标准输入读取一个单词。

如果这是一个新的单词,则在 word_count
中添 加以该单词为索引的新元素。

如果读入的单词已在 map
对象中,则将它所对应
的值加 1。

其中最有趣的是,在单词第一次出现时,会在 word_count
中创建并插入一 个以该单词为索引的新元素,

同时将它的值初始化为 0。然后其值立即加 1,所
以每次在 map 中添加新元素时,

所统计的出现次数正好从 1
开始。

-----------------------

b. 使用insert

m.insert(e)

m.insert(beg,end)

m.insert(iter,e)

word_count.insert(map<string, int>::value_type("Anna", 1));

map<string, int>::value_type(”anna“, 1)

是一个新创建的 pair
对象,将直接插入到 map
容器中。谨记 value_type 是 pair<const K, V>
类型的同义词,K 为键类型,而 V
是键所关联的值的类 型。insert
的实参创建了一个适当的 pair 类型新对象,该对象将插入到 map
容器。在添加新 map 元素时,使用 insert
成员可避免使用下标操作符所带来 的副作用:不必要的初始化。

传递给 insert
的实参相当笨拙。可用两种方法简化:使用 make_pair:

word_count.insert(make_pair("Anna", 1));

或使用 typedef

typedef map<string,int>::value_type valType;

word_count.insert(valType("Anna", 1));

带有一个键-值 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

}

3）查找并读取map中的元素

a.使用下标

map<string, int> word_count;

int occurs = word_count["foot"];

使用下标存在一个很危险的副作用:如果该键不在 map
容器中,那
么下标操作会插入一个具有该键的新元素。

此时occurs = 0;

b.使用count

word_count.count("foot");//返回foot的次数

c.使用find//返回指向该元素的迭代器，不存在返回超出末端的迭代器

int occurs = 0;

map<string,int>::iterator it = word_count.find("foobar");

if (it != word_count.end())

occurs = it->second;

3）从map中的删除元素

m.erase(k)

删除 m
中键为 k 的元素。返回 size_type
类型的值,表示删除
的元素个数

m.erase(p)

从 m
中删除迭代器 p 所指向的元素。p
必须指向 m 中确实存在
的元素,而且不能等于 m.end()。返回 void

m.(b,e)从 m
中删除一段范围内的元素,该范围由迭代器对 b
和 e 标记。 b
和 e 必须标记 m
中的一段有效范围:即 b
和 e 都必须指向 m
中的元素或最后一个元素的下一个位置。而且,b 和 e
要么相等 (此时删除的范围为空),要么 b
所指向的元素必须出现在 e 所
指向的元素之前。返回 void 类型

4)遍历

map 同样提供 begin
和 end 运算,以生成用于遍历整个
容器的迭代器。

例如,可如下将 map
容器 word_count
的内容输出:

map<string, int>::const_iterator map_it = word_count.begin();

while (map_it != word_count.end()) {

cout << map_it->first << " occurs "

<< map_it->second << " times" << endl;

++map_it;

}

(2)set

#include<set>