前言

上一節分析了pair結構, 正是為map分析做鋪墊, map本身實現也不難, 其資料儲存是pair, 儲存結構是RB-tree, 即map也並不能說是關聯容器, 而應該是配接器.

map操作

map的insert必須是以pair為儲存結構, 當然也可以直接使用make_pair構造一個臨時pair, 這個函式我們上節分析pair的時候講過.

int main()
{
	map<string, int> m;
	pair<string, int> p;
	p.first = "zero", p.second = 0;
	m.insert(p)
 
;
	m.insert(make_pair("one", 1));

	if(!m.empty())
	{
		cout << m["one"] << " " << m["two"] << endl;	// 1 0
		cout << (*m.find("one")).first << " " << (*m.find("one")).second << endl;	// one 1
	}

	exit(0);
}

上面唯一比較複雜的就是(*m.find("one")).second的操作, 這在我們下面分析過載[]

map分析

map基本結構定義

map物件例項化map<const T1, T2>, 鍵值是不能直接修改的, 而資料可以修改.

#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:
  typedef Key key_type;	// 定義鍵值
  typedef T data_type;	// 定義資料
  typedef T mapped_type;
  typedef pair<const Key, T> value_type; // 這裡定義了map的資料型別為pair, 且鍵值為const型別, 不能修改
  typedef Compare key_compare;
    
private:
  typedef rb_tree<key_type, value_type, 
                  select1st<value_type>, key_compare, Alloc> rep_type;	// 定義紅黑樹, map是以rb-tree結構為基礎的
  rep_type t;  // red-black tree representing 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;
  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;
	...
};

巢狀類 : 這是一個仿函式, 為鍵值key提供比較介面

class map {
public:
	...
    // 這是一個仿函式, 為鍵值key提供比較介面
  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);
    }
  };
    ...
};

建構函式 map的所有插入操作都是呼叫的是RB-tree的insert_unique, 不允許出現重複的鍵

class map {
public:
	...
public:
  // allocation/deallocation
  map() : t(Compare()) {}	// 預設建構函式
  explicit map(const Compare& comp) : t(comp) {}
#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 */
    ...
};

基本型別屬性獲取

class map {
public:
	...
public:
    // 實際呼叫的是RB-tree的key_comp函式
  key_compare key_comp() const { return t.key_comp(); }
    // value_comp實際返回的是一個仿函式value_compare
  value_compare value_comp() const { return value_compare(t.key_comp()); }
    // 以下的begin, end等操作都是呼叫的是RB-tree的介面
  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(); }
    // 交換, 呼叫RB-tree的swap, 實際只交換head和count
  void swap(map<Key, T, Compare, Alloc>& x) { t.swap(x.t); }
    ...
};
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);
}

過載

class map {
public:
	...
public:
  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; 
  }
    ...
};
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;
}

過載操作重點分析 []

1. insert(value_type(k, T()) : 查詢是否存在該鍵值, 如果存在則返回該pair, 不存在這重新構造一該鍵值並且值為空
2. *((insert(value_type(k, T()))).first) : pair的第一個元素表示指向該元素的迭代器, 第二個元素指的是(false與true)是否存在, first 便是取出該迭代器而 * 取出pair.
3. (*((insert(value_type(k, T()))).first)).second : 取出pair結構中的second儲存的資料

class map {
public:
	...
public:
    // 1.  insert(value_type(k, T()) : 查詢是否存在該鍵值, 如果存在則返回該pair, 不存在這重新構造一該鍵值並且值為空
	// 2.  *((insert(value_type(k, T()))).first) : pair的第一個元素表示指向該元素的迭代器, 第二個元素指的是(false與true)是否存在,  first 便是取出該迭代器而 * 取出pair.
	// 3.  (*((insert(value_type(k, T()))).first)).second : 取出pair結構中的second儲存的資料
  T& operator[](const key_type& k) {
    return (*((insert(value_type(k, T()))).first)).second;
  }
    ...
};

map的其他insert, erase, find都是直接呼叫RB-tree的介面函式實現的, 這裡就不直接做分析了.

總結

實際map也是以RB-tree為底層介面的配接器, 同時map還以pair結構為儲存結構, 當這兩個都理解後整個map結構分析也就很輕鬆了.