map排序的第三个参数《转》

 

今天被同事问到一个问题，map中第三个参数的意思是什么，于是写了下面这个程序测试了一下。

#include <map>
#include <iostream>
using namespace std;

typedef map<int,char> icMap;
typedef map<int,char>::iterator It;

class func
{
public:
    func(){};
    bool operator ()( const int i1, const int i2 )
    {
        return i1>i2;
    }
};

typedef map<int,char,func> icMapCmp;
typedef map<int,char,func>::iterator It1;

int main(void)
{
    icMap m;
    m.insert(make_pair(1,'1'));
    m.insert(make_pair(3,'3'));
    m.insert(make_pair(2,'2'));

    for (It it = m.begin();it!=m.end();++it)
    {
        cout<<it->first<<"\t"<<it->second<<endl;
    }

    icMapCmp c;
    c.insert(make_pair(1,'1'));
    c.insert(make_pair(3,'3'));
    c.insert(make_pair(2,'2'));
    for (It1 it1 = c.begin();it1!=c.end();++it1)
    {
        cout<<it1->first<<"\t"<<it1->second<<endl;
    }

    return 0;
}

 

第三个参数MSDN的解释如下：

Traits

The type that provides a function object that can compare two element values as sort keys to determine their relative order in the map. This argument is optional and the binary predicate less<Key> is the default value.

MSDN上说的已经很清楚了，缺省的是 std::less

看stl_map.h中看map的定义：

 template <typename _Key, typename _Tp, typename _Compare = std::less<_Key>,

            typename _Alloc = std::allocator<std::pair<const _Key, _Tp> > >

class map

缺省的compare确实是std::less，std::less。在stl_function.h中std::less的实现如下：

 template <class _Tp>
    struct less : public binary_function<_Tp, _Tp, bool>
    {
      bool
      operator()(const _Tp& __x, const _Tp& __y) const
      { return __x < __y; }
};

 

return __x < __y;原来如此。但是这仅仅是比较函数，比较了之后map又是如何处理的呢？好像还是没有找到根源。

那就继续追踪，map的构造函数：

      map()

      : _M_t(_Compare(), allocator_type()) { }

用_Compare()初始化了_M_t，那就继续追踪_M_t，追踪到了map内部的红黑树。

      typedef _Rb_tree<key_type, value_type, _Select1st<value_type>,

                     key_compare, _Pair_alloc_type> _Rep_type;

 

      /// @if maint  The actual tree structure.  @endif

      _Rep_type _M_t;

最后到了insert_unique函数中：

template<typename _Key, typename _Val, typename _KeyOfValue,
          typename _Compare, typename _Alloc>
   pair<typename _Rb_tree<_Key, _Val, _KeyOfValue,
           _Compare, _Alloc>::iterator, bool>
   _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
   insert_unique(const _Val& __v)
   {
     _Link_type __x = _M_begin();
     _Link_type __y = _M_end();
     bool __comp = true;
     while (__x != 0)
{
  __y = __x;
  __comp = _M_impl._M_key_compare(_KeyOfValue()(__v), _S_key(__x));
  __x = __comp ? _S_left(__x) : _S_right(__x);
}
     iterator __j = iterator(__y);
     if (__comp)
if (__j == begin())
  return pair<iterator,bool>(_M_insert(__x, __y, __v), true);
else
  --__j;
     if (_M_impl._M_key_compare(_S_key(__j._M_node), _KeyOfValue()(__v)))
return pair<iterator, bool>(_M_insert(__x, __y, __v), true);
     return pair<iterator, bool>(__j, false);

 

函数前面的返回值类型定义有点复杂，其实就是返回pair<iterator, bool>的pair，然后根据要插入的值__v来比较，如果是真，就往左边找，否则就往右边找。

template<typename _Key, typename _Val, typename _KeyOfValue,
          typename _Compare, typename _Alloc>
   typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::iterator
   _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::
   _M_insert(_Base_ptr __x, _Base_ptr __p, const _Val& __v)
   {
     bool __insert_left = (__x != 0 || __p == _M_end()
            || _M_impl._M_key_compare(_KeyOfValue()(__v),
                          _S_key(__p)));

     _Link_type __z = _M_create_node(__v);

     _Rb_tree_insert_and_rebalance(__insert_left, __z, __p,
                this->_M_impl._M_header);
     ++_M_impl._M_node_count;
     return iterator(__z);
   }

找到位置之后，创建节点，然后插入到二叉平衡树（也就是红黑树）中。

哈哈哈，_Rb_tree_insert_and_rebalance找不到代码。居然在STLPort里面找到了下面的代码。

template <class _Key, class _Value, class _KeyOfValue,
          class _Compare, class _Alloc> __iterator__
_Rb_tree<_Key,_Value,_KeyOfValue,_Compare,_Alloc> ::_M_insert(_Rb_tree_node_base* __x_, _Rb_tree_node_base* __y_, const _Value& __v,
  _Rb_tree_node_base* __w_)
{
  _Link_type __w = (_Link_type) __w_;
  _Link_type __x = (_Link_type) __x_;
  _Link_type __y = (_Link_type) __y_;
  _Link_type __z;

  if ( __y == this->_M_header._M_data ||
       ( __w == 0 && // If w != 0, the remainder fails to false
         ( __x != 0 ||     // If x != 0, the remainder succeeds to true
           _M_key_compare( _KeyOfValue()(__v), _S_key(__y) ) )
     )
       ) {

    __z = _M_create_node(__v);
    _S_left(__y) = __z;               // also makes _M_leftmost() = __z
                                      //    when __y == _M_header
    if (__y == this->_M_header._M_data) {
      _M_root() = __z;
      _M_rightmost() = __z;
    }
    else if (__y == _M_leftmost())
      _M_leftmost() = __z;   // maintain _M_leftmost() pointing to min node
  }
  else {
    __z = _M_create_node(__v);
    _S_right(__y) = __z;
    if (__y == _M_rightmost())
      _M_rightmost() = __z;  // maintain _M_rightmost() pointing to max node
  }
  _S_parent(__z) = __y;
  _S_left(__z) = 0;
  _S_right(__z) = 0;
  _Rb_global_inst::_Rebalance(__z, this->_M_header._M_data->_M_parent);
  ++_M_node_count;
  return iterator(__z);
}