第11章 关联容器(C++ Primer 5th)

map<string, size_t> word_count;		// string 到 size_t的空map
string word;
while(cin >> word)
    ++word_count[word];		// 提取word的计数器并将其加1
for (const auto &w : word_count)	// 对map中的每个元素 打印结果
    cout << w.first << " occurs " << w.second
    	 << ((w.second > 1) ? " times" : " time") << endl;

// 统计输入单词从每个单词出现的次数
map<string, size_t> word_count;		// string 到 size_t 的空 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的计数器

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

// 定义一个有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

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

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

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

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

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

pair<string, int>
process(vector<string>& v) {
    // 处理 v
    
    if (!v.empty()) 
        return {v.back(), v.bcak().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());

set<string>::value_type vl;			// 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

// 获得指向 word_count 中一个元素的迭代器
auto map_it = word_count.begin();
// *map_it 是一个 pair<const string, size_t> 对像的引用
cout << map_it->first;		// 打印此元素的key
cout << " " << map_it -> second;	// 打印此元素的value
map_it->first = "new key";		// 错误，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 中的key(value) 是只读的
	cout << *set_it < endl;		// 正确
}

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

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

// 统计每个单词在输入中出现次数的一种更繁琐的写法
map<string, size_t> word_count> word_count;	
string word;
while(cin >> word) {
    // 插入一个元素， key 等于 word, value 为1
    auto ret = word_count.insert({word, 1});
    if (!ret.second) {		// word 已在 word_count 中
        ++ret.first->second;	// 递增计数器
    }
}

//  等价表达式
++((ret.first)->second);
// 展开解释
// ret   保存insert返回的值，是一个 pair 类型
// ret.first   是pair的第一个成员，是一个map的迭代器，指向具有给定key的元素
// ret.fist->  解引用此迭代器，提取map中的元素，元素是一个pair
// ret.first->second   map中元素的value部分
// ++ret.first->second;  递增此值

// ret 的声明和初始化，不使用auto
pair<map<string, size_t>::iterator, bool> ret =
     word_count.insert({word, 1});

multimap<string, string> authors;
// 插入第一个元素， 关键字为 Barth, John
authors.insert({"Barth, John", "sot-Weed Factor"});
// 正确： 添加第二元素，关键字也是 Barth, John
authors.insert({"Barth, John", "Lost in the Funhouse"});

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

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

cout << word_count["Anna"];   // 用 Anna 作为下标提取元素的value
++word_count["Anna"];		  // 提取元素，将其增1
cout << word_count["Anna"];	 

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(11);		// 返回0

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

string search_iterm("Alain de Botton");		// 要查找的作者
auto entries = authors.count(search_iterm);	//元素的数量
auto iter = authors.find(search_iterm);		// 此作者的第一本书
// 用一个循环查找此作者的所有著作
while(entries) {
    cout << iter->second << endl;
    ++iter;
    --entries;
}

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

// authors 和 search_item 的定义， 与前面的程序一样
// pos 保存迭代器对，表示与关键字匹配的元素范围
for (auto pos = authors.equal_range(search_item);
     pos.first != pos.second; ++pos.first)
    cout << pos.first->second << endl;  

unordered_map<string, size_t> word_count;		// string 到 size_t的空map
string word;
while(cin >> word)
    ++word_count[word];		// 提取word的计数器并将其加1
for (const auto &w : word_count)	// 对map中的每个元素 打印结果
    cout << w.first << " occurs " << w.second
    	 << ((w.second > 1) ? " times" : " time") << endl;

containers. occurs 1 time
use occurs 1 time
can occurs 1 time
examples occurs 1 time