STL关联式容器之map

map的特性是，所有元素都会根据元素的键值自动被排序。map的所有元素都是pair，同时拥有实值(value)和键值(key)。pair的第一元素被视为键值，第二元素被视为实值。map不允许两个元素拥有相同的键值。下面是<stl_pair.h>中pair的定义

cpp 复制代码

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) {}
};

我们可以通过map的迭代器改变map的元素内容吗？如果想要修正元素的键值，答案是不行的，因为map元素的键值关系到map元素的排列规则。任意改变map元素键值将会严重破坏map组织。如果想要修改元素的实值，答案是可以的，因为map元素的实值并不影响map元素的排列规则。因此，map iterators既不是一种constant iterators,也不是一种mutble iterators.

map拥有和list相同的某些性质：当客户端对它进行元素新增操作(insert)或删除操作(erase)时，操作之前的所有迭代器，在操作完成之后都依然有效。当然被删除的那个元素的迭代器必然是个例外。

由于RB-tree是一种平衡二叉搜索树，自动排序的效果很不错，所以标准的STL map即以RB-tree为底层机制。又由于map所开放的各种操作接口，RB-tree也都提供了，所以几乎所有的map操作行为，都只转调用RB-tree的操作行为而已。

下图所示map的架构

pair的第一个元素视为键值(key)，第二个键值视为实值(value)。源码摘录如下：

cpp 复制代码

// 注意，以下Key为键值（key）型别，T为实值(value)型别
template <class Key, class T, class Compare = less<Key>, class Alloc=alloc>
class map {
public:
    typedef Key key_type;       // 键值型别
    typedef T data_type;
    typedef T mapped_type;
    typedef pair<class Key, T> value_type;
    typedef Compare key_compare;
    
    class value_compre
    : 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;

public:
    typedef typename rep_type::pointer pointer;
    typedef typename rep_type::const_pointer const_pointer;
    typedef typename rep_type::reference reference;
    typedef typename rep_type::const_reference const_reference;
    typedef typename rep_type::iterator iterator;
    typedef typename rep_type::const_iterator const_iterator;
    typedef typename rep_type::reverse_iterator reverse_iterator;
    typedef typename rep_type::const_reverse_iterator const_reverse_iterator;
    typedef typename rep_type::size_type size_type;
    typedef typename rep_type::difference_type difference_type;
// 注意 map底层使用的插入函数为insert_uniqueue;multimap底层会使用insert_equal进行插入
    
    map() ： t(Compare()) {}
    explicit map(const Compare& comp) : t(comp) {}

    template <class InputIterator>
    map(InputIterator first, InputIterator last) 
    : t(Compare()) {
        t.insert_unique(first, last);
    }

    template <class InputIterator>
    map(InputIterator first, InputIterator last, const Compare& comp) 
    : t(comp) {
        t.insert_unique(first, last);
    }

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

    key_compare key_comp() const { return t.key_comp(); }
    value_compare value_comp() cosnt { return t.value_comp(); }
    iterator begin() { return t.begin(); }
    const_iterator begin() const { return t.begin(); }
    iterator end() { return t.end(); }
    iterator end() const { return t.end(); }
    reverse_iterator rbegin() { return t.rbegin(); }
    const_reverse_iterator rbegin() { return t.rbegin(); }
    bool empty() { return t.empty(); }
    size_type size() { return t.size(); }
    size_type max_size() { return t.max_size(); }
    
    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); }

    pair<iterator, bool> insert(const value_type&x) {
        return t.insert_unique(x);
    }

    iterator insert(iterator position, cosnt value_type&x) {
        return t.insert_unique(position, x);
    }

    template<class InputIterator> 
    void insert(InputIterator first, InputIterator last) {
        return t.insert_unique(first, last);
    }

    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(); }

    iterator find(cosnt key_type&x) { return t.find(x); }
    const_iterator find(const key_type&x) const { return t.find(x); }
    size_type count(const key_type&x) const { t.count(x); }
    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); }

    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); }

    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 == STL_NULL_TMPL_ARGS (const map&, const map&);
    friend bool operator < STL_NULL_TMPL_ARGS (const map&, const map&);
 };

cpp 复制代码

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;
}