STL源码剖析(容器适配器)

在STL中，有一类容器完全以底部容器为基础进行实现，这类容器归类为container adapter。

priority_queue

priority_queue默认使用vector为基础，加上heap算法，其实现比较简单。

 template <class T, class Sequence = vector<T>,
           class Compare = less<typename Sequence::value_type> >
 class  priority_queue {
 public:
     typedef typename Sequence::value_type value_type;
     typedef typename Sequence::size_type size_type;
     typedef typename Sequence::reference reference;
     typedef typename Sequence::const_reference const_reference;
 protected:
     Sequence c;
     Compare comp;
 public:
     priority_queue() : c() {}

     template <class InputIterator>
     priority_queue(InputIterator first, InputIterator last, const Compare& x)
         : c(first, last), comp(x) { make_heap(c.begin(), c.end(), comp); }

     // 只是对Sequence方法跟heap算法的封装
     bool empty() const { return c.empty(); }
     size_type size() const { return c.size(); }
     const_reference top() const { return c.front(); }
     void push(const value_type& x) {
         c.push_back(x);
         push_heap(c.begin(), c.end(), comp);
     }
     void pop() {
         pop_heap(c.begin(), c.end(), comp);
         c.pop_back();
     }
 };

stack

stack则默认使用deque为基础，可以通过指定第二个模板参数来指定底部容器。

为什么stack不默认使用vector/list作为底层容器呢？

原因是因为vector在扩容的时候有较差的时间复杂度，而list虽然有平稳的时间复杂度，但是总体平均复杂度较高，

因此折中的使用deque作为stack的底层容器。

 template <class T, class Sequence = deque<T> >
 class stack {
 public:
     typedef typename Sequence::value_type value_type;
     typedef typename Sequence::size_type size_type;
     typedef typename Sequence::reference reference;
     typedef typename Sequence::const_reference const_reference;
 protected:
     Sequence c;
 public:
     // 实际上是对Sequence的封装
     bool empty() const { return c.empty(); }
     size_type size() const { return c.size(); }
     reference top() { return c.back(); }
     const_reference top() const { return c.back(); }
     void push(const value_type& x) { c.push_back(x); }
     void pop() { c.pop_back(); }
 };

queue

queue的实现跟原理跟stack差不多。

 // STL中list也可以作为其底层容器
 template <class T, class Sequence = deque<T> >
 class queue {
 public:
     typedef typename Sequence::value_type value_type;
     typedef typename Sequence::size_type size_type;
     typedef typename Sequence::reference reference;
     typedef typename Sequence::const_reference const_reference;
 protected:
     Sequence c;
 public:
     // 实际上也是对Sequence的封装
     bool empty() const { return c.empty(); }
     size_type size() const { return c.size(); }
     reference front() { return c.front(); }
     const_reference front() const { return c.front(); }
     reference back() { return c.back(); }
     const_reference back() const { return c.back(); }
     void push(const value_type& x) { c.push_back(x); }
     void pop() { c.pop_front(); }
 };