C++ STL容器之 map

map 是一种有序无重复的关联容器。

关联容器与顺序容器不一样，他们的元素是按照关键字来保存和访问的，而顺序元素是按照它们在容器中的位置保存和访问的。

map保存的是一种 key - value 的pair对象，其中 key 是关键字，value 是关键字对应的值。经过 key找到对应的 value。map中按照 key的大小升序排列pair对象。

typedef pair<const Key, T> value_type

其中key 是 const的，即不能够改变map中的key。

在map中定位特定的元素比 unordered_map 要慢，由于在 map中须要根据 key的大小进行顺序查找。

可是在map中容许直接选取必定范围的元素。

map在底层一般用二叉搜索树实现。

template < class Key,                                     // map::关键字类型
           class T,                                       // map::值类型
           class Compare = less<Key>,                     // map::关键字比较函数
           class Alloc = allocator<pair<const Key,T> >    // map::allocator类
           > class map;

模板参数的第三个 class Compare = less<Key> 是一种比较函数

经过这个比较函数，map能比较两个不一样的 key值的大小关系，及是否相等。默认采用 less<Key>， 即 Key 类型的 "<"操做符。

若是 Key类型没有"<"操做符的定义，则须要提供一个自定义比较函数的函数指针，来做为Compare函数。

构造函数

　　(1) 默认构造： map<Key, value> m;　　构造一个空的map，注意，必要时要给出模板参数中的 Compare。须要时给出 Alloc

　　(2) 范围构造： map<key, value> m(iterator first, iterator last);　　将迭代器[frist, last)范围内的元素填入map中

　　(3) 拷贝构造： map<key, value> m(cosnt map& m2);　　用m2构造m

　　(4) 初始化列表构造： map<key, value> m(initializer_list<value_type> il)

　　　　　　　　　　　　 因为map 的 value_type 是 pair类型，因此要构形成pair做为列表，这是三种构造 pair的方式

　　　　　　　　　　　　 map<key, value> m{{key k1, value v1},{k2, v2}, ...}　　// 经过 {}构造 pair

　　　　　　　　　　　　 map<key, value> m{make_pair(key k1, value v1), make_pair(k2, v2), ...}　　// 经过 make_pair() 函数构造 pair

　　　　　　　　　　　　 map<key, value> m{pair<key, value>(k1, v1), pair<key, value>(k2, v2), ...}　　// 经过类型转换构造 pair

赋值操做符=

　　map& operator= (const map& x)　  // map赋值

　　map& operator= (map&& x)　　　　// 不懂

　　map& operator= (initializer_list<value_type> il)　　// 参数列表赋值

迭代器

　　begin, end, rbegin, rend

　　cbegin, cend, crbegin, crend

　　map 的迭代器支持 ++, -- 操做，可是不支持 +i 操做。

　　注意 map中是根据 key的值来排列元素的位置的，因此经过迭代器遍历出来的结果顺序，可能和插入值的顺序不一样。

　　另外对 map的迭代器解引用的结果是获得一个 pair类型的对象。它有两个共有成员 first, second。first保存 key的值，second 保存value的值。

　　因为map的 key 是 const的，因此获得的 pair 的first 也是const 的。

成员函数

　　容量

　　　　empty()　　// 若是map 为空，返回true。不然返回 false

　　　　　　　　　　// bool empty() const noexcept;

　　　　size()　　　 // 返回map 中元素的大小，即 key-value 的个数

　　　　　　　　　　// size_type size() const noexcept;

　　　　max_size()  　　// 返回因为存储空间的限制，map有可能包含的最大元素数。但不保证必定能达到这个数量，有可能在中途申请空间失败。

　　　　　　　　　　　　 // size_type max_size() const noexcept;

　　元素访问

　　　　操做符[]　　// m[k] 返回map 中 Key为 k的元素的value的引用。

　　　　　　　　　　// 若是 k不存在，那么将会插入一个 key为 k的元素，并返回其默认 value。

　　　　　　　　　　// []操做总会将 map的大小 +1

　　　　　　　　　　// 注意，对于map，解引用迭代器获得 pair，操做符[]获得 value

　　　　at()　　　　// m.at(k) 返回map中Key为k的元素的value的引用。

　　　　　　　　　　// 若是k不存在，抛一个 out_of_range 异常。

　　　　　　　　　　// 使用 at 不会添加元素，不会增长 map的大小

　　修改

　　　　insert　　插入

　　　　　　　　　(1) pair<iterator, bool> insert(const pair<key, value> &val);

　　　　　　　　　　 // 单个值插入，参数为 pair类型，first 为 key, second为 value

　　　　　　　　　　 // 返回值也是一个 pair，first为插入后的 iterator，second 为bool类型， true表示插入成功，false 表示插入失败

　　　　　　　　　　 // 插入失败是由于 map 中已经有一个 key 与输入相同。此次插入操做对map 不会有任何影响， 失败时返回值的 first指向已有的key-value

　　　　　　　　　(2) iterator insert(const_iterator pos, const pair<key, value> &val);

　　　　　　　　　　  // 提示值插入

　　　　　　　　　　  // 从 pos 指定的位置开始查找 val应该插入的位置

　　　　　　　　　　  // 若是设定值合适，能够减小插入时作查找的时间

　　　　　　　　　(3) void insert(iterator first, iterator second);

　　　　　　　　　　  // 范围插入，插入[first, second)范围内的内容

　　　　　　　　　(4) void insert(initializer_list<value_type> il);

　　　　　　　　　　  // 初始化列表插入

　　　　emplace　　高效插入

　　　　　　　　  和 insert的主要区别在于，insert首先构造一个临时 value_type对象，再copy到 map中。

　　　　　　　　  而emplace 是直接在map里根据参数构造 value_type对象。更高效。

　　　　　　　　  pair<iterator, bool> emplace(key k, value v);

　　　　　　　　  返回值与 insert状况相同。

　　　　emplace_hint　　提示位置的高效插入

　　　　　　　　  iterator emplace(const iterator pos, key k, value v);

　　　　　　　　  从pos开始查找应该插入的位置，其他和 emplace相同。

　　　　erase　　删除

　　　　　　　　  (1) iterator erase(const_iterator position);　　// 删除迭代器指向的内容, 函数返回 NULL

　　　　　　　　  (2) iterator erase(const_iterator first, const_iterator last);　　// 删除迭代器范围内的内容，函数返回NULL

　　　　　　　　  (3) size_type erase(const key_type &k);　　 // 删除 type 为k的元素，返回删除的数目。对于 map，成功删除返回1，k不存在则返回0

　　　　　　　　  (4) 1，2中若是迭代器无效，会产生 undefined behavior

　　　　swap　　交换两个 map对象的内容

　　　　　　　　  (1) void swap(map &x)

　　　　　　　　  (2) void swap(map &x1, map &x2)　　// 非成员重载函数

　　　　clear　　清空一个容器的全部元素

　　　　　　　　  void clear() noexcept;

　　操做

　　　　find　　查找

　　　　　　　　在map中查找key 为 k的元素，返回指向它的迭代器。若k不存在，返回 map::end.

　　　　　　　　// iterator find(const key_type &k);

　　　　count　 计数

　　　　　　　　 统计map中 key为k的元素的个数，对于map，返回值不是1(存在)，就是0(不存在)

　　　　　　　　 // size_type count(const key_type &k) const;