STL源代码分析集装箱 stl

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

set

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

全部元素都会依据元素的键值自己主动被排序。

不能够通过 set 的迭代器改变 set 的元素值。由于 set 元素值就是其键值。关系到 set 元素的排列规则。

set<T>::iterator 被定义为底层 RB-tree 的 const_iterator，杜绝写入操作

标准的 STL set 以 RB-tree 为底层机制，就像 stack 以 deque 为底层机制一样

multiset和 set 基本一样。仅仅只是在插入的时候调用的是底层 RB-tree 的 insert_equal()，同意元素反复

演示样例：

struct ltstr

{

  bool operator()(const char* s1, const char* s2) const

  {

    return strcmp(s1, s2) < 0;

  }

};

int main()

{

  const int N = 6;

  const char* a[N] = {"isomer", "ephemeral", "prosaic",

                      "nugatory", "artichoke", "serif"};

  const char* b[N] = {"flat", "this", "artichoke",

                      "frigate", "prosaic", "isomer"};

  set<const char*, ltstr> A(a, a + N);

  set<const char*, ltstr> B(b, b + N);

  set<const char*, ltstr> C;

  cout << "Set A: ";

  copy(A.begin(), A.end(), ostream_iterator<const char*>(cout, " "));

  cout << endl;

  cout << "Set B: ";

  copy(B.begin(), B.end(), ostream_iterator<const char*>(cout, " "));

  cout << endl;

  cout << "Union: ";

  set_union(A.begin(), A.end(), B.begin(), B.end(),

            ostream_iterator<const char*>(cout, " "),

            ltstr());

  cout << endl;

  cout << "Intersection: ";

  set_intersection(A.begin(), A.end(), B.begin(), B.end(),

                   ostream_iterator<const char*>(cout, " "),

                   ltstr());

  cout << endl;

  set_difference(A.begin(), A.end(), B.begin(), B.end(),

                 inserter(C, C.begin()),

                 ltstr());

  cout << "Set C (difference of A and B): ";

  copy(C.begin(), C.end(), ostream_iterator<const char*>(cout, " "));

  cout << endl;

}

源代码：

#ifndef __SGI_STL_INTERNAL_SET_H

#define __SGI_STL_INTERNAL_SET_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 Compare = less<Key>, class Alloc = alloc>

#else

template <class Key, class Compare, class Alloc = alloc>

#endif

class set {

public:

  // typedefs:

  //key_type 和 value_type 的类型是一样的

  typedef Key key_type;

  typedef Key value_type;

  //key_compare 和 value_compare 也用到了同一个比較函数

  typedef Compare key_compare;

  typedef Compare value_compare;

private:

  //底层採用红黑树来实现 set --> 參见 Effective C++ ，这是利用了 Composition 的 is-implimented-in-terms-of 的功能

  typedef rb_tree<key_type, value_type,

                  identity<value_type>, key_compare, Alloc> rep_type;

  rep_type t;  // red-black tree representing set

public:

  typedef typename rep_type::const_pointer pointer;

  typedef typename rep_type::const_pointer const_pointer;

  typedef typename rep_type::const_reference reference;

  typedef typename rep_type::const_reference const_reference;

  //set 的 iterator 定义为红黑树的 const_iterator，这表示 set 的迭代器无法运行写入操作。

  //这是由于 set 的元素有一定次序安排，不同意用户在随意处进行写入操作

  typedef typename rep_type::const_iterator iterator;

  typedef typename rep_type::const_iterator const_iterator;

  typedef typename rep_type::const_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

  // set 一定要使用 RB-tree 的 insert-unique() 。这样当要插入

  //已经存在的键值时，会选择忽略

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

  explicit set(const Compare& comp) : t(comp) {}

#ifdef __STL_MEMBER_TEMPLATES

  template <class InputIterator>

  set(InputIterator first, InputIterator last)

    : t(Compare()) { t.insert_unique(first, last); }

  template <class InputIterator>

  set(InputIterator first, InputIterator last, const Compare& comp)

    : t(comp) { t.insert_unique(first, last); }

#else

  set(const value_type* first, const value_type* last)

    : t(Compare()) { t.insert_unique(first, last); }

  set(const value_type* first, const value_type* last, const Compare& comp)

    : t(comp) { t.insert_unique(first, last); }

  set(const_iterator first, const_iterator last)

    : t(Compare()) { t.insert_unique(first, last); }

  set(const_iterator first, const_iterator last, const Compare& comp)

    : t(comp) { t.insert_unique(first, last); }

#endif /* __STL_MEMBER_TEMPLATES */

  set(const set<Key, Compare, Alloc>& x) : t(x.t) {}

  set<Key, Compare, Alloc>& operator=(const set<Key, Compare, Alloc>& x) {

    t = x.t;     // 调用了底层红黑树的 operator= 函数

    return *this;

  }

  //下面全部的 set 操作行为，RB-tree 都已提供，所以 set 仅仅要调用就可以

  // accessors:

  key_compare key_comp() const { return t.key_comp(); }

  value_compare value_comp() const { return t.key_comp(); }

  iterator begin() const { return t.begin(); }

  iterator end() const { return t.end(); }

  reverse_iterator rbegin() const { return t.rbegin(); }

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

  void swap(set<Key, Compare, Alloc>& x) { t.swap(x.t); }

  // insert/erase

  typedef  pair<iterator, bool> pair_iterator_bool;

  pair<iterator,bool> insert(const value_type& x) {

    pair<typename rep_type::iterator, bool> p = t.insert_unique(x);

    return pair<iterator, bool>(p.first, p.second);

  }

  iterator insert(iterator position, const value_type& x) {

    typedef typename rep_type::iterator rep_iterator;

    return t.insert_unique((rep_iterator&)position, x);

  }

#ifdef __STL_MEMBER_TEMPLATES

  template <class InputIterator>

  void insert(InputIterator first, InputIterator last) {

    t.insert_unique(first, last);

  }

#else

  void insert(const_iterator first, const_iterator last) {

    t.insert_unique(first, last);

  }

  void insert(const value_type* first, const value_type* last) {

    t.insert_unique(first, last);

  }

#endif /* __STL_MEMBER_TEMPLATES */

  void erase(iterator position) {

    typedef typename rep_type::iterator rep_iterator;

    t.erase((rep_iterator&)position);

  }

  size_type erase(const key_type& x) {

    return t.erase(x);

  }

  void erase(iterator first, iterator last) {

    typedef typename rep_type::iterator rep_iterator;

    t.erase((rep_iterator&)first, (rep_iterator&)last);

  }

  void clear() { t.clear(); }

  // set operations:

  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) const {

    return t.lower_bound(x);

  }

  iterator upper_bound(const key_type& x) const {

    return t.upper_bound(x);

  }

  pair<iterator,iterator> equal_range(const key_type& x) const {

    return t.equal_range(x);

  }

  friend bool operator== __STL_NULL_TMPL_ARGS (const set&, const set&);

  friend bool operator< __STL_NULL_TMPL_ARGS (const set&, const set&);

};

template <class Key, class Compare, class Alloc>

inline bool operator==(const set<Key, Compare, Alloc>& x,

                       const set<Key, Compare, Alloc>& y) {

  return x.t == y.t;

}

template <class Key, class Compare, class Alloc>

inline bool operator<(const set<Key, Compare, Alloc>& x,

                      const set<Key, Compare, Alloc>& y) {

  return x.t < y.t;

}

#ifdef __STL_FUNCTION_TMPL_PARTIAL_ORDER

template <class Key, class Compare, class Alloc>

inline void swap(set<Key, Compare, Alloc>& x,

                 set<Key, 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_SET_H */

// Local Variables:

// mode:C++

// End:

巴特西

STL源代码分析集装箱 stl_set.h

最新文章

热门文章

巴特西

STL源代码分析 集装箱 stl_set.h

最新文章

热门文章

STL源代码分析集装箱 stl_set.h