【深度探索STL】关联式容器map和multimap

map与multimap的区别等同于set 与multiset的区别。

一、map

map的特性是，所有元素都会根据元素的键值自动被排序。map中的所有元素都是pair（意味着两个元素），同时拥有实质（value）和键值（key）。pair的第一元素被视为键值，第二元素被视为实质。回忆set，set 中的所有元素都是单个的（实值就是键值，键值就是实值）。map不允许两个元素拥有相同的键值。

下面是pair的定义

template <class T1, class T2>
struct pair {
typedef T1 first_type;
typedef T2 second_type;

T1 first;
T2 second;
pair() : first(T1()), second(T2()) {}
pair(const T1& a, const T2& b) : first(a), second(b) {}

};

从上可以看出，pair 包含两个类型（可以相同，也可以不相同）的公共元素。

map同set一样，都是关联式容器，内部元素的实值都会根据其键值来进行排序（set 的实值就是键值），所以都不能任意改变元素的键值，但是map可以任意改变元素的实值，我们所有操作的前提以及是否被允许，要看是否会影响到map元素的排序规则。

同样map和multimap 也是以RB-tree 为底层机制，几乎所有的map操作行为，都只是转调用RB-tree的操作行为而已。

set 和 map的内部结构即元素的存储都是RB-tree，set 中，RB-tree的节点内容是单一元素，而map中，节点内容则是一个pair（<key，value>）。

class map {
public:

// typedefs:

typedef Key key_type; //键值型别
typedef T data_type;  //实值型别
typedef pair<const Key, T> value_type;  //元素性别（键值/实值）
typedef Compare key_compare;  //键值比较函数

//定义一个函数，其作用就是调用“元素比较函数”
class value_compare
: public binary_function<value_type, value_type, bool> {
friend class map<Key, T, Compare, Alloc>;
protected:
Compare comp;
value_compare(Compare c) : comp(c) {}
public:
//重载
bool operator()(const value_type& x, const value_type& y) const {
return comp(x.first, y.first);
}
};

private:
typedef rb_tree<key_type, value_type,
select1st<value_type>, key_compare, Alloc> rep_type;
rep_type t;  // 以RB-tree为底层实现，所有元素(pair)存放在RB-tree节点中
public:
//两种类型的都有，因为map允许用户通过迭代器修改元素的实值
typedef rep_type::pointer pointer;
typedef rep_type::reference reference;
typedef rep_type::const_reference const_reference;
typedef rep_type::iterator iterator;
typedef rep_type::const_iterator const_iterator;
typedef rep_type::reverse_iterator reverse_iterator;
typedef rep_type::const_reverse_iterator const_reverse_iterator;
typedef rep_type::size_type size_type;
typedef rep_type::difference_type difference_type;

// allocation/deallocation
//构造函数
map() : t(Compare()) {}
explicit map(const Compare& comp) : t(comp) {}

/*map一定使用底层RB-tree 的insert_unique()*/

map(const map<Key, T, Compare, Alloc>& x) : t(x.t) {}
map<Key, T, Compare, Alloc>& operator=(const map<Key, T, Compare, Alloc>& x)
{
t = x.t;
return *this;
}

// accessors:
//转调用RB-tree的操作行为
key_compare key_comp() const { return t.key_comp(); }
value_compare value_comp() const { return value_compare(t.key_comp()); }
iterator begin() { return t.begin(); }
const_iterator begin() const { return t.begin(); }
iterator end() { return t.end(); }
const_iterator end() const { return t.end(); }
reverse_iterator rbegin() { return t.rbegin(); }
const_reverse_iterator rbegin() const { return t.rbegin(); }
reverse_iterator rend() { return t.rend(); }
const_reverse_iterator rend() const { return t.rend(); }
bool empty() const { return t.empty(); }
size_type size() const { return t.size(); }
size_type max_size() const { return t.max_size(); }
/*下面这个下标操作符重载函数是的map支持元素的直接存取，索引值是元素的key*/
T& operator[](const key_type& k)
{
return (*((insert(value_type(k, T()))).first)).second;
}

void swap(map<Key, T, Compare, Alloc>& x) { t.swap(x.t); }

// insert/erase
//都是调用底层RB-tree的操作行为
pair<iterator, bool> insert(const value_type& x) { return t.insert_unique(x); }
iterator insert(iterator position, const value_type& x) {
return t.insert_unique(position, x);
}

void erase(iterator position) { t.erase(position); }
size_type erase(const key_type& x) { return t.erase(x); }
void erase(iterator first, iterator last) { t.erase(first, last); }
void clear() { t.clear(); }

// map operations:
/*返回一个迭代器指向键值为key的元素，如果没找到就返回end()*/
iterator find(const key_type& x) { return t.find(x); }
const_iterator find(const key_type& x) const { return t.find(x); }
/*返回键值等于key的元素的个数*/
size_type count(const key_type& x) const { return t.count(x); }
/*返回一个迭代器，指向键值>=key的第一个元素*/
iterator lower_bound(const key_type& x) { return t.lower_bound(x); }
const_iterator lower_bound(const key_type& x) const {
return t.lower_bound(x);
}
/*返回一个迭代器，指向键值>key的第一个元素*/
iterator upper_bound(const key_type& x) { return t.upper_bound(x); }
const_iterator upper_bound(const key_type& x) const {
return t.upper_bound(x);
}
/*返回键值为key的元素的第一个可安插位置和最后一个可安插位置，也就是“键值==key”的元素区间*/
pair<iterator, iterator> equal_range(const key_type& x) {
return t.equal_range(x);
}
pair<const_iterator, const_iterator> equal_range(const key_type& x) const {
return t.equal_range(x);
}
friend bool operator==(const map&, const map&);
friend bool operator<(const map&, const map&);
};

/*运算符重载，几乎有所有的操作行为都是调用RB-tree的操作行为
事实上，包括set在内的关联式容器内部都是以RB-tree方式存放的*/
template <class Key, class T, class Compare, class Alloc>
inline bool operator==(const map<Key, T, Compare, Alloc>& x,
const map<Key, T, Compare, Alloc>& y) {
return x.t == y.t;
}

template <class Key, class T, class Compare, class Alloc>
inline bool operator<(const map<Key, T, Compare, Alloc>& x,
const map<Key, T, Compare, Alloc>& y) {
return x.t < y.t;
}

通常，关联式容器并不提供元素的直接存取，你必须依靠迭代器，不过 map 内部的下标操作符重载函数使得其支持元素的直接存取，看看它是怎么实现的
这是map作为关联式容器特殊的地方（multimap没有哦）

/*下面这个下标操作符重载函数是的map支持元素的直接存取，索引值是元素的key*/
T& operator[](const key_type& k)
{
return (*((insert(value_type(k, T()))).first)).second;
}
/*map中的元素，是一个由键值和实值组成的pair
value_type(k, T()) //typedef pair<const Key, T> value_type;产生一个与实值型别相同的暂时对象替代
//就是产生一个键值为k，实值未知的对象
insert(value_type(k, T())) //将该元素插入到map里面，该操作返回一个pair，其第一个元素是个迭代器
//指向插入妥当的新元素或指向插入失败点(键值重复)的旧元素
*((insert(value_type(k, T()))).first) //先取插入操作所返回的pair的第一元素，即指向被插入元素的迭代器
//然后通过指针运算符提领该迭代器
(*((insert(value_type(k, T()))).first)).second //取其第二个元素，也就是实值
*/

操作 m[key] 返回一个 reference，指向键值为key 的元素的实值，如果该元素尚未存在，就安插该元素。map 是根据键值 key来排序的，实值不影响。

因为是返回一个 reference，可作为左值，并且是指向可修改的实值，所以同样可以利用下标操作符修改对应键值的实值。set 不具备的原因就是，其键值就是实值，不可修改。

二、multimap

同multiset类似，multimap 的特性以及用法几乎与map 完全相同，唯一的差别在于它允许键值重复，当然还有上面说到的这个直接存取，插入操作采用的是底层机制RB-tree 的 insert_equal()。

#include <iostream>
#include <map>

using namespace std;

int main()
{
map<string, int> imap; //以string 为键值，以int 为实值
/*利用下标操作符，不存在的元素则安插（源码得知，内部调用insert()函数）*/
imap[string("qwer")] = 1;
imap[string("tyui")] = 2;
imap[string("asdf")] = 3;
imap[string("ghjk")] = 4;

pair<string, int> value(string("zxcv"), 5);
imap.insert(value);

int number = imap[string("zxcv")];//下标操作符获取元素的实值
cout << number << endl; // 5

imap[string("zxcv")] = 1;//左值运用
number = imap[string("zxcv")];
cout << number << endl; // 1

return 0;
}

关联式容器如set和map(multi..) 的erase操作，并没有返回值，不像序列式容器返回删除元素的下一个迭代器，所以一旦执行erase操作，如果不做处理极易发生危险。比如下面操作：

for (pos = stocks.begin(); pos != stocks.end(); ++pos)
{
if (pos->second == value)
stocks.erase(pos);//删除了pos。pos立马失效，++pos立即出错
}map应用案例

#include <iostream>
#include <map>
#include <string>

using namespace std;

int main()
{
typedef map<string, double> StringDoubleMap;

StringDoubleMap stocks;

/*不知道是哪一年的股票价格*/
stocks["BASF"] = 369.50;
stocks["VM"] = 413.50;
stocks["Daimler"] = 819.10;
stocks["BMW"] = 834.30;
stocks["Siemens"] = 842.20;

StringDoubleMap::iterator pos;
for (pos = stocks.begin(); pos != stocks.end(); ++pos)
{
cout << "stocks: " << pos->first << "\t"
<< "price: " << pos->second << endl;
}
cout << endl;
/*移除迭代器所指元素*/
double Express = 0.000001;
for (pos = stocks.begin(); pos != stocks.end();)
{
if (abs(pos->second - 834.30) < Express)
stocks.erase(pos++);//这里是防止迭代器失效
else
++pos;
}
for (pos = stocks.begin(); pos != stocks.end(); ++pos)
{
cout << "stocks: " << pos->first << "\t"
<< "price: " << pos->second << endl;
}
cout << endl;

return 0;
}

参考书籍《STL 源码剖析》、《STL 标准程序库》