STL源码剖析容器 stl_map.h

本文为senlie原创，转载请保留此地址：http://blog.csdn.net/zhengsenlie

map

--------------------------------------------------------------------------------

所有元素都会根据元素的键值自动被排序。

map的所有元素都是 pair，同时拥有实值和键值。

不可以修改元素的键值，因为它关系到 map 元素的排列规则

可以修改元素的实值，因为它不影响 map 的排列规则

map iterator 既不是一种 constant iterators ，也不是一种 mutable iterator

标准 STL map 以 RB-tree 为底层机制。

multimap 和 map 基本一样，只不过在插入的时候调用的是底层 RB-tree 的 insert_equal()，允许元素重复

图 5-20

示例：

struct ltstr
{
  bool operator()(const char* s1, const char* s2) const
  {
    return strcmp(s1, s2) < 0;
  }
};

int main()
{
  map<const char*, int, ltstr> months;

  months["january"] = 31; //这里调用了两个函数, 先调用 map 的operator[] 函数返回键值对应实值的引用， 再调用该实值类型的 operator= 函数进行赋值
  months["february"] = 28;
  months["march"] = 31;
  months["april"] = 30;
  months["may"] = 31;
  months["june"] = 30;
  months["july"] = 31;
  months["august"] = 31;
  months["september"] = 30;
  months["october"] = 31;
  months["november"] = 30;
  months["december"] = 31;

  cout << "june -> " << months["june"] << endl;
  map<const char*, int, ltstr>::iterator cur  = months.find("june");
  map<const char*, int, ltstr>::iterator prev = cur;
  map<const char*, int, ltstr>::iterator next = cur;
  ++next;
  --prev;
  cout << "Previous (in alphabetical order) is " << (*prev).first << endl;
  cout << "Next (in alphabetical order) is " << (*next).first << endl;
}

源码：

//stl_pair.h里 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) {}

#ifdef __STL_MEMBER_TEMPLATES
  template <class U1, class U2>
  pair(const pair<U1, U2>& p) : first(p.first), second(p.second) {}
#endif
};

//stl_map.h 源码
#ifndef __SGI_STL_INTERNAL_MAP_H
#define __SGI_STL_INTERNAL_MAP_H

__STL_BEGIN_NAMESPACE

#if defined(__sgi) && !defined(__GNUC__) && (_MIPS_SIM != _MIPS_SIM_ABI32)
#pragma set woff 1174
#endif

#ifndef __STL_LIMITED_DEFAULT_TEMPLATES
template <class Key, class T, class Compare = less<Key>, class Alloc = alloc>
#else
template <class Key, class T, class Compare, class Alloc = alloc>
#endif
class map {
public:

// typedefs:

  typedef Key key_type;  //键值类型
  typedef T data_type;   //数值类型
  typedef T mapped_type;
  typedef pair<const Key, T> value_type; //元素类型(键值/实值)
  typedef Compare key_compare; //键值比较函数

  // functor， 其作用是调用 "元素比较函数"
  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); //以 x, y 的键值调用了键值比较函数
    }
  };

private:
  typedef rb_tree<key_type, value_type,
                  select1st<value_type>, key_compare, Alloc> rep_type;
  rep_type t;  // 以红黑树表现 map
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;
  //set 的 iterator 定义为 const ，因为它不允许改变 set 里的值
  //map 的 iterator 不定义为 const，因为它虽不允许改变键值，但允许改变实值
  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;

  // allocation/deallocation

  map() : t(Compare()) {}
  explicit map(const Compare& comp) : t(comp) {}// 传递 Compare() 产生的函数对象给底层的红黑树作为初始化时设定的比较函数

  //不允许键值重复，所以只能使用 RB-tree 的 insert_unique()
#ifdef __STL_MEMBER_TEMPLATES
  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); }
#else
  map(const value_type* first, const value_type* last)
    : t(Compare()) { t.insert_unique(first, last); }
  map(const value_type* first, const value_type* last, const Compare& comp)
    : t(comp) { t.insert_unique(first, last); }

  map(const_iterator first, const_iterator last)
    : t(Compare()) { t.insert_unique(first, last); }
  map(const_iterator first, const_iterator last, const Compare& comp)
    : t(comp) { t.insert_unique(first, last); }
#endif /* __STL_MEMBER_TEMPLATES */

  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;  // 调用了底层红黑树的 operator= 函数
    return *this;
  }

   //以下所有的 map 操作行为，RB-tree 都已提供，所以 map 只要调用即可
  // accessors:

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

  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);
  }
#ifdef __STL_MEMBER_TEMPLATES
  template <class InputIterator>
  void insert(InputIterator first, InputIterator last) {
    t.insert_unique(first, last);
  }
#else
  void insert(const value_type* first, const value_type* last) {
    t.insert_unique(first, last);
  }
  void insert(const_iterator first, const_iterator last) {
    t.insert_unique(first, last);
  }
#endif /* __STL_MEMBER_TEMPLATES */

  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:

  iterator find(const 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 { return 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&);
};

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

#ifdef __STL_FUNCTION_TMPL_PARTIAL_ORDER

template <class Key, class T, class Compare, class Alloc>
inline void swap(map<Key, T, Compare, Alloc>& x,
                 map<Key, T, Compare, Alloc>& y) {
  x.swap(y);
}

#endif /* __STL_FUNCTION_TMPL_PARTIAL_ORDER */

#if defined(__sgi) && !defined(__GNUC__) && (_MIPS_SIM != _MIPS_SIM_ABI32)
#pragma reset woff 1174
#endif

__STL_END_NAMESPACE

#endif /* __SGI_STL_INTERNAL_MAP_H */

// Local Variables:
// mode:C++
// End:

STL源码剖析容器 stl_map.h

时间： 2024-10-12 04:29:18

STL源码剖析容器 stl_map.h的相关文章

《STL源码剖析》---stl_map.h阅读笔记

map是STL中的标准关系容器,它存储的元素时pair,拥有键值key和实值value.按照键值key存储到红黑树中.map中不允许两个键值相同的元素.当元素插入到红黑树中后,键值key不可以再修改,但是其实值value可以修改,因为map的迭代器不是constant iterator,而是mutable iterator. G++ 2.91.57,cygnus\cygwin-b20\include\g++\stl_map.h 完整列表 /* * * Copyright (c) 1994 * H

STL源码剖析容器 stl_vector.h

本文为senlie原创,转载请保留此地址:http://blog.csdn.net/zhengsenlie vector ---------------------------------------------------------------------- 描述: 1.迭代器 vector 维护的是一个连续线性空间,它的迭代器是普通指针, 能满足 RandomAccessIterator 所有必要条件:operator*, operator->,operator++,operator--,

STL源码剖析容器 stl_set.h

本文为senlie原创,转载请保留此地址:http://blog.csdn.net/zhengsenlie set ------------------------------------------------------------------------ 所有元素都会根据元素的键值自动被排序. 不可以通过 set 的迭代器改变 set 的元素值.因为 set 元素值就是其键值,关系到 set 元素的排列规则. set<T>::iterator 被定义为底层 RB-tree 的 const

STL源码剖析容器 stl_tree.h

本文为senlie原创,转载请保留此地址:http://blog.csdn.net/zhengsenlie RB-tree(红黑树) -------------------------------------------------------------------------- 平衡二叉搜索树 --> 平衡可提高搜索效率常见的平衡二叉搜索树有: AVL-tree(任何节点的左右子树高度相差最多 1).红黑树.AA-tree AVL-tree 破坏平衡的情况及恢复平衡的方法恢复时要先找到失

STL源码剖析容器 stl_hashtable.h

本文为senlie原创,转载请保留此地址:http://blog.csdn.net/zhengsenlie hashtable --------------------------------------------------------------------------- 二叉搜索树具有对数平均时间的表现,它建立在输入数据有足够的随机性的假设 hashtable 有常数平均时间的表现,基于统计,不需依赖输入元素的随机性 hashtalbe 的简单实现: 所有元素都 16-bits 不带正负

STL源码剖析容器 stl_list.h

本文为senlie原创,转载请保留此地址:http://blog.csdn.net/zhengsenlie list ---------------------------------------------------------------------- ??为什么很多在算法库里有的算法还要在类的成员函数里重新实现一遍? -->1.因为算法库里的是通用的,对于具体的类来说效率不高. 比如说 reverse 如果直接用 stl_algo.h 里的 reverse,会再调用 iter_swap,

STL源码剖析容器 stl_deque.h

本文为senlie原创,转载请保留此地址:http://blog.csdn.net/zhengsenlie deque ------------------------------------------------------------------------ ??一直看不懂 operator->() ,不明白它为什么不用接受参数,直接 return &(operator*()) 好像我们用迭代器的时候也不没怎么用到这个函数,甚至我都不会用 1.概述 vector 是单向开口的连续线性空

STL源码剖析容器 stl_stack.h

本文为senlie原创,转载请保留此地址:http://blog.csdn.net/zhengsenlie stack ------------------------------------------------------------- stack 是一种配接器(adapter),以某种容器作为底部结构,改变其接口,使之符合"先进后出"的特性. SGI STL 默认以 deque 为 stack 底部结构没有遍历行为,没有遍历器示例: #include <stack&g

STL源码剖析容器 stl_queue.h

本文为senlie原创,转载请保留此地址:http://blog.csdn.net/zhengsenlie queue ---------------------------------------------------------------------- stack 是一种配接器(adapter),以某种容器作为底部结构,改变其接口,使之符合"先进先出"的特性. SGI STL 默认以 deque 为 stack 底部结构没有遍历行为,没有遍历器示例: #include &l

STL源码剖析 容器 stl_map.h

STL源码剖析 容器 stl_map.h的相关文章

STL源码剖析容器 stl_map.h

STL源码剖析容器 stl_map.h的相关文章