map<string, size_t> word_count;while(cin>>word)    ++word_count[word];for(const auto &w : word_count)    {        cout << w.first << w.second    }

map<string, size_t> word_count;set<string> exclude = {"the","a","hello"};while(cin>>word)    if(exclude.find(word) == exclude.end())         ++word_count[word];

'类型别名'iteratorconst_iteratorvalue_type //容器元素类型。定义方式： vector<int>::value_typereference //元素类型的引用。定义方式： vector<int>::referenceconst_reference //元素的 const 左值类型
'构造函数'-'三种通用的构造函数：同类拷贝、迭代器范围初始化、列表初始化'C c1;                          // 默认构造函数，构造空容器。C c1 (c2);                    // 拷贝构造函数，容器类型与元素类型必须都相同C c1 (c2.begin(), c2.end());  // 要求两种元素类型可以转换即可。C c1 {a, b, c, ...};          // 使用初始化列表，容器的大小与初始化列表一样大        // 只有顺序容器的构造函数可以接受大小参数，关联容器不行。
'赋值与swap'c1 = c2;c1 = {a,b,c,....}a.swap(b);swap(a,b);//两种 swap 等价
'大小'c.size();c.max_size();//c 可以保存的最大元素数目，是整个内存层面的容量，不是已分配内存。不同于 caplity, caplity 只能用于 vector，queue，stringc.empty();
'添加/删除元素（不适用于array）'c.insert(args); //将 args 中的元素拷贝进 c，args 是一个迭代器或迭代器范围c.emplace(inits);//使用 inits 构造 c 中的一个元素c.erase(args);//删除指定的元素，args 是一个迭代器或迭代器范围c.clear();
'关系运算符'==; !=; <; <=; >; >=  //所有容器都支持相等和不等运算符。无序关联容易不支持大于小于运算符。
'获取迭代器'c.begin(); c.end(); c.cbegin(); c.cend(); //返回 const_iterator
'反向容器的额外成员'reverse_iterator //逆序迭代器，这是一个和 iterator 不同的类型const_reverse_iterator c.rbegin();c.rend();c.crbegin();c.crend();

'类型别名'key_type //关键字类型mapped_type //每个关联的类型，只适用于 mapvalue_type //对于 set，与 key_type 相同，对于 map，为 pair<const key_type,mapped_type>

map<string, int> word_count = {{"a", 1}, {"b", 2}};set<string> exclude = {"the", "a"};

'比较函数的定义方式'bool comp(const Sales_data &lhs, const Sales_data &rhs){    return lhs.isbn() < rhs.isbn();}'定义容器对象'multiset<Sales_data,decltype(comp)*> bookstore(comp);

'直接定义'pair<string, int> p;//默认初始化pair<string, int> p(str, i);pair<string, int> p{"lala", 16};pair<string, int> p = {"lala", 16};
'使用 make_pair'auto p = make_pari(v1, v2);//pair 的类型根据 v1 和 v2 的类型推断。

pair<string,int> process(bool a){    if(a)         return {"lala",16};//列表初始化    else         return pair<string,int>();//隐式构造返回值}
'也可以使用make_pair'return make_pair(v.back, v.back.size());

'类型别名'key_type //关键字类型mapped_type //每个关联的类型，只适用于 mapvalue_type //对于 set，与 key_type 相同，对于 map，为 pair<const key_type,mapped_type>

map<string, int> m;'四种方法'm.insert({word, 1});                    //最简单的方法，直接使用花括号m.insert(make_pair(word, 1));m.insert(pair<string, int>(word, 1));   //pair 类型直接定义m.insert(map<string, int>::value_type(word, 1));

s.emplace(args);//args用来构造一个元素，其他和 s.insert(10) 相同s.emplace(iter, args);//除了 args 其他和 s.insert(iter, 10) 相同

while(cin>>word){    auto ret = word_count.insert({word,1});    if(ret.second = false)        ++ret.first->second;}
'解释'ret : 保存insert返回的值，是一个pairret.first : 是pair的第一个成员，是一个map迭代器，指向具有给定关键字的元素ret.first-> : 解引用此迭代器,提取map中的元素，元素也是一个pairret.first->second : map中元素的值部分++ret.first->second : 递增
'替换'pair<map<string,size_t>::iterator, bool> ret = word_count.insert({word,1});

'与顺序容器相似版本的 erase's.erase(iter);           // 删除一个元素，返回 voids.erase(iter1, iter2)    // 删除一个范围，返回 void'额外版本'auto cnt = s.erase("lala");//删除一个关键字，返回该关键字对应的元素的数量

m.erase(--m.end());   // 正确！m 的迭代器支持自增与自减m.erase(m.rbegin());  // 错误！

'map'map<int, int> m;for(auto iter = m.begin(); iter != m.end(); ){    if(iter->second == 0)        m.erase(iter++); //这是循环map删除指定元素的唯一方式。利用了 i++ 的原理    else        iter++;    }'vector'vector<int> v;for(auto iter = v.begin(); iter != v.end(); ){    if(*iter == 0)        iter = v.erase(iter);//vecotr 的 erase 操作返回所删除元素之后的迭代器    else        iter++;    }

c[k]    返回关键字为k的元素；如果k不在c中，添加一个关键字为k的元素，对其值初始化。c.at(k)    访问关键字为k的元素，带参数检查；若k不存在在c中，抛出一个out_of_range异常。

'基本的访问操作'c[k];c.at(k);

'查找操作'c.find(k);//返回一个迭代器，指向关键字为 k 的元素，如果 k 不在容器中，返回尾后迭代器。c.count(k);//返回关键字等于 k 的元素数量。c.lower_bound(k);//返回一个迭代器，指向第一个关键字不小于 k 的元素。c.upper_bound(k);//返回一个迭代器，指向第一个关键字大于 k 的元素。c.equal_range(k);//返回一个迭代器 pair，表示关键字等于 k 的元素范围。若干 k 不存在，pair 的两个成员相等，指向可以安全插入 k 的位置

if(word_count.find("lala") == word_count.end())if(word_count.count("lala") == 0)

string a("hello world");auto sum = authors.count(a);   //此作者一共有几本书suto iter = authors.find(a);  //此作者第一本书while (sum)    cout << iter->second << endl;    ++iter;    -- sum;

for(auto bg = authors.lower_bound(a), ed = authors.upper_bound(a); bg != ed; ++bg)    cout << beg->second << endl;

for(auto pos = authors.equal_range(a); pos.first != pos.second; ++pos.first)    cout << pos.first->second;

'桶接口'c.bucket_count();      //返回正在使用的桶的数目c.max_bucket_count();  //返回容器能容纳的最多的桶的数量c.bucket_size(n);      //返回第 n 个桶中有多少个元素c.bucket(k);           //返回关键字为 k 的元素所在的桶
'桶迭代'local_iterator         //类型别名，可以用来访问桶中元素的迭代器类型const_local_iterator   //类型别名，桶迭代器的常量版本c.begin(n), c.end(n)  //返回桶 n 的首元素迭代器和尾后迭代器c.cbegin(n),c.cend(n) 
'哈希策略'c.load_factor();      //返回每个桶的平均元素数量，类型为 floatc.max_load_factor();  //返回 c 试图维护的平均桶大小，类型为 float。c 会在需要时添加新的桶，始终保持 load_factor <= max_loat_factorc.rehash(n);          //重组存储，使得 bucket_count >= n 且 bucket_count > size / max_load_factorc.reserve(n);         //重组存储，使得 c 可以保存 n 个元素而不必 rehash。

'定义自己的 hash 模板版本'size_t hasher(const Sales_data &sd){    return hash<string>() (sd.isbn());//这里采用了标准库的 hash 类型对象来计算 isbn 成员的哈希值，作为整个 Sale_data 对象的哈希值。}'重载比较函数（这里是相等）'bool eq(const Sales_data &lhs, const Sales_data &rhs){    return lhs.isbn() == rhs.isbn();}'定义 unordered_multiset'unordered_multiset< Sales_data, decltype(hasher)*, decltype(eq)* > sals;