std::map的使用

map类的实现代码

template<class _Kty,
  class _Ty,
  class _Pr = less<_Kty>,
  class _Alloc = allocator<pair<const _Kty, _Ty> > >
  class map
    : public _Tree<_Tmap_traits<_Kty, _Ty, _Pr, _Alloc, false> >
  { // ordered red-black tree of {key, mapped} values, unique keys
public:
  typedef map<_Kty, _Ty, _Pr, _Alloc> _Myt;
  typedef _Tree<_Tmap_traits<_Kty, _Ty, _Pr, _Alloc, false> > _Mybase;
  typedef _Kty key_type;
  typedef _Ty mapped_type;
  typedef _Ty referent_type;  // retained
  typedef _Pr key_compare;
  typedef typename _Mybase::value_compare value_compare;
  typedef typename _Mybase::allocator_type allocator_type;
  typedef typename _Mybase::size_type size_type;
  typedef typename _Mybase::difference_type difference_type;
  typedef typename _Mybase::pointer pointer;
  typedef typename _Mybase::const_pointer const_pointer;
  typedef typename _Mybase::reference reference;
  typedef typename _Mybase::const_reference const_reference;
  typedef typename _Mybase::iterator iterator;
  typedef typename _Mybase::const_iterator const_iterator;
  typedef typename _Mybase::reverse_iterator reverse_iterator;
  typedef typename _Mybase::const_reverse_iterator
    const_reverse_iterator;
  typedef typename _Mybase::value_type value_type;

  map()
    : _Mybase(key_compare(), allocator_type())
    { // construct empty map from defaults
    }

  map(const _Myt& _Right)
    : _Mybase(_Right)
    { // construct map by copying _Right
    }

  explicit map(const key_compare& _Pred)
    : _Mybase(_Pred, allocator_type())
    { // construct empty map from comparator
    }

  map(const key_compare& _Pred, const allocator_type& _Al)
    : _Mybase(_Pred, _Al)
    { // construct empty map from comparator and allocator
    }

  template<class _Iter>
    map(_Iter _First, _Iter _Last)
    : _Mybase(key_compare(), allocator_type())
    { // construct map from [_First, _Last), defaults
    this->insert(_First, _Last);
    }

  template<class _Iter>
    map(_Iter _First, _Iter _Last,
      const key_compare& _Pred)
    : _Mybase(_Pred, allocator_type())
    { // construct map from [_First, _Last), comparator
    this->insert(_First, _Last);
    }

  template<class _Iter>
    map(_Iter _First, _Iter _Last,
      const key_compare& _Pred, const allocator_type& _Al)
    : _Mybase(_Pred, _Al)
    { // construct map from [_First, _Last), comparator, and allocator
    this->insert(_First, _Last);
    }

  _Myt& operator=(const _Myt& _Right)
    { // assign by copying _Right
    _Mybase::operator=(_Right);
    return (*this);
    }

  map(_Myt&& _Right)
    : _Mybase(_STD move(_Right))
    { // construct map by moving _Right
    }

  _Myt& operator=(_Myt&& _Right)
    { // assign by moving _Right
    _Mybase::operator=(_STD move(_Right));
    return (*this);
    }

  mapped_type& operator[](key_type&& _Keyval)
    { // find element matching _Keyval or insert with default mapped
    iterator _Where = this->lower_bound(_Keyval);
    if (_Where == this->end()
      || this->comp(_Keyval, this->_Key(_Where._Mynode())))
      _Where = this->insert(_Where,
        _STD pair<key_type, mapped_type>(
          _STD move(_Keyval),
          mapped_type()));
    return ((*_Where).second);
    }

  void swap(_Myt& _Right)
    { // exchange contents with non-movable _Right
    _Mybase::swap(_Right);
    }

  void swap(_Myt&& _Right)
    { // exchange contents with movable _Right
    _Mybase::swap(_STD move(_Right));
    }

 #if _HAS_CPP0X

 #else /* _HAS_CPP0X */

 #if _HAS_STRICT_CONFORMANCE
  void erase(const_iterator _Where)
    { // erase element at _Where
    _Mybase::erase(_Where);
    }

  size_type erase(const key_type& _Keyval)
    { // erase and count all that match _Keyval
    return (_Mybase::erase(_Keyval));
    }

  void erase(const_iterator _First, const_iterator _Last)
    { // erase [_First, _Last)
    _Mybase::erase(_First, _Last);
    }
 #endif /* _HAS_STRICT_CONFORMANCE */

 #endif /* _HAS_CPP0X */

  mapped_type& operator[](const key_type& _Keyval)
    { // find element matching _Keyval or insert with default mapped
    iterator _Where = this->lower_bound(_Keyval);
    if (_Where == this->end()
      || this->comp(_Keyval, this->_Key(_Where._Mynode())))
      _Where = this->insert(_Where,
        value_type(_Keyval, mapped_type()));
    return ((*_Where).second);
    }

 #if _HAS_CPP0X
  mapped_type& at(const key_type& _Keyval)
    { // find element matching _Keyval
    iterator _Where = this->lower_bound(_Keyval);
    if (_Where == this->end()
      || this->comp(_Keyval, this->_Key(_Where._Mynode())))
      _Xout_of_range("invalid map<K, T> key");
    return ((*_Where).second);
    }

  const mapped_type& at(const key_type& _Keyval) const
    { // find element matching _Keyval
    const_iterator _Where = this->lower_bound(_Keyval);
    if (_Where == this->end()
      || this->comp(_Keyval, this->_Key(_Where._Mynode())))
      _Xout_of_range("invalid map<K, T> key");
    return ((*_Where).second);
    }
 #endif /* _HAS_CPP0X */
  }

std::map实际应用

OutputDebugString("*************************************************************************\n");
  OutputDebugString("*************************************************************************\n");
  OutputDebugString("*************************************************************************\n");
  OutputDebugString("*************************************************************************\n");

  // 任务ID  根据任务创建实验的ID
  typedef std::map<int, int>           IDMAP;
  typedef std::map<int, int>::iterator IDMAPPt;
  typedef std::pair<int, int>          IDMAPPair;

  IDMAP   *idMap = new IDMAP;
  for(int i=1;i<=10;i++)
  {
    idMap->insert(IDMAPPair(i,i*10));
  }

  for (IDMAPPt it = idMap->begin(); it != idMap->end(); it++)
  {
    it->first;
    it->second;
    CString str ;
    str.Format("%7d%7d\n",it->first,it->second);
    OutputDebugString(str);
  }
  OutputDebugString("*************************************************************************\n");

  IDMAPPt it;
  it = idMap->begin();
  while(it != idMap->end())
  {
    if(it->first == 5)
    {
      // 查找指定元素的位置
      IDMAPPt pos = idMap->find(it->first);

      // 删除指定位置的元素
      idMap->erase(pos);

      int i=0;

      // 获取容器的大小
      i = idMap->size();

      if(i>0)
      {
        // 将ptr定位到容器的开始
        it = idMap->begin();
      }
      continue;
    }

    it->first;
    it->second;
    CString str ;
    str.Format("%7d%7d\n",it->first,it->second);
    OutputDebugString(str);

    it++;
  }
  OutputDebugString("*************************************************************************\n");
  
  for (IDMAPPt it = idMap->begin(); it != idMap->end(); it++)
  {
    it->first;
    it->second;
    CString str ;
    str.Format("%7d%7d\n",it->first,it->second);
    OutputDebugString(str);
  }

</pre><pre>

输出结果

*************************************************************************
*************************************************************************
*************************************************************************
*************************************************************************
      1     10
      2     20
      3     30
      4     40
      5     50
      6     60
      7     70
      8     80
      9     90
     10    100
*************************************************************************
      1     10
      2     20
      3     30
      4     40
      1     10
      2     20
      3     30
      4     40
      6     60
      7     70
      8     80
      9     90
     10    100
*************************************************************************
      1     10
      2     20
      3     30
      4     40
      6     60
      7     70
      8     80
      9     90
     10    100