STL源码学习系列十： 容器配接器( Stack）

容器配接器( Stack）

---

概述

stack是一种“先进后出”的数据结构，它只能在栈顶对数据进行操作，即只能在栈顶进行新增元素、移除元素、取得最顶端元素。不能进行遍历行为，所以不需要设计自己的迭代器。在SGI STL的源码<stl_stack.h>的设计中，它是基于某种容器作为底部结构的，默认容器是deque容器，用户也可以自己指定容器的类型，比如list或者vector。

---

stack容器配接器

由于stack是以底部容器完成其所有操作，而具有这种“修改某物接口、形成另一种风貌”的性质，称之为adapter（配接器）。因此stl stack往往不被归类为容器，而被归类为配接器。

// 以下为使用deque时的布局
//
// 栈底                      当前栈顶                         预留的内存边界
// ↓                            ↓                                 ↓
// --------------------------------------------------------------------
// |   |   | ...... |   |   |   |   |   |   |   | ......  |   |   | X |
// --------------------------------------------------------------------
//                              ↑   ↑                             ↑
//                              |   |                             |
//                              |   -------------------------------
//                              |    这里是尚未使用的预留内存, 可能为0
//                              |
//                       仅支持在这里进行push(), pop(), top()操作

 

  由于源码比较短，同时是基于其他容器进行操作的，这里只给出源码的剖析：

#ifndef __SGI_STL_INTERNAL_STACK_H  
#define __SGI_STL_INTERNAL_STACK_H  
  
#include <sequence_concepts.h>  
  
__STL_BEGIN_NAMESPACE  
  
// Forward declarations of operators == and <, needed for friend declaration.  
//这里默认的底层容器类型是deque容器  
template <class _Tp,   
          class _Sequence __STL_DEPENDENT_DEFAULT_TMPL(deque<_Tp>) >  
class stack;  
  
template <class _Tp, class _Seq>  
bool operator==(const stack<_Tp,_Seq>& __x, const stack<_Tp,_Seq>& __y);  
  
template <class _Tp, class _Seq>  
bool operator<(const stack<_Tp,_Seq>& __x, const stack<_Tp,_Seq>& __y);  
  
  
template <class _Tp, class _Sequence>  
class stack {  
  
  // requirements:  
  
  __STL_CLASS_REQUIRES(_Tp, _Assignable);  
  __STL_CLASS_REQUIRES(_Sequence, _BackInsertionSequence);  
  typedef typename _Sequence::value_type _Sequence_value_type;  
  __STL_CLASS_REQUIRES_SAME_TYPE(_Tp, _Sequence_value_type);  
  
  
#ifdef __STL_MEMBER_TEMPLATES  
  template <class _Tp1, class _Seq1>  
  friend bool operator== (const stack<_Tp1, _Seq1>&,  
                          const stack<_Tp1, _Seq1>&);  
  template <class _Tp1, class _Seq1>  
  friend bool operator< (const stack<_Tp1, _Seq1>&,  
                         const stack<_Tp1, _Seq1>&);  
#else /* __STL_MEMBER_TEMPLATES */  
  friend bool __STD_QUALIFIER  
  operator== __STL_NULL_TMPL_ARGS (const stack&, const stack&);  
  friend bool __STD_QUALIFIER  
  operator< __STL_NULL_TMPL_ARGS (const stack&, const stack&);  
#endif /* __STL_MEMBER_TEMPLATES */  
  
public:  
    // 由于stack仅支持对栈顶元素的操作, 所以不定义STL要求的    
    // pointer, iterator, difference_type   
  typedef typename _Sequence::value_type      value_type;  
  typedef typename _Sequence::size_type       size_type;  
  typedef          _Sequence                  container_type;  
  
  typedef typename _Sequence::reference       reference;  
  typedef typename _Sequence::const_reference const_reference;  
protected:  
  _Sequence c;//底层容器类型，默认为deque容器  
public:  
    //下面对stack的维护完全依赖于底层容器的操作  
  stack() : c() {}  
  explicit stack(const _Sequence& __s) : c(__s) {}  
  
  //判断容器是否为空  
  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(); }  
};  
  
//下面是依赖于底层容器的操作运算符  
template <class _Tp, class _Seq>  
bool operator==(const stack<_Tp,_Seq>& __x, const stack<_Tp,_Seq>& __y)  
{  
  return __x.c == __y.c;  
}  
  
template <class _Tp, class _Seq>  
bool operator<(const stack<_Tp,_Seq>& __x, const stack<_Tp,_Seq>& __y)  
{  
  return __x.c < __y.c;  
}  
  
#ifdef __STL_FUNCTION_TMPL_PARTIAL_ORDER  
  
template <class _Tp, class _Seq>  
bool operator!=(const stack<_Tp,_Seq>& __x, const stack<_Tp,_Seq>& __y)  
{  
  return !(__x == __y);  
}  
  
template <class _Tp, class _Seq>  
bool operator>(const stack<_Tp,_Seq>& __x, const stack<_Tp,_Seq>& __y)  
{  
  return __y < __x;  
}  
  
template <class _Tp, class _Seq>  
bool operator<=(const stack<_Tp,_Seq>& __x, const stack<_Tp,_Seq>& __y)  
{  
  return !(__y < __x);  
}  
  
template <class _Tp, class _Seq>  
bool operator>=(const stack<_Tp,_Seq>& __x, const stack<_Tp,_Seq>& __y)  
{  
  return !(__x < __y);  
}  
  
#endif /* __STL_FUNCTION_TMPL_PARTIAL_ORDER */  
  
__STL_END_NAMESPACE  
  
#endif /* __SGI_STL_INTERNAL_STACK_H */  
  
// Local Variables:  
// mode:C++  
// End:  

这里给出例子：

// constructing stacks  
#include <iostream>       // std::cout  
#include <stack>          // std::stack  
#include <vector>         // std::vector  
#include <deque>          // std::deque  
  
int main ()  
{  
  std::deque<int> mydeque (3,100);          // deque with 3 elements  
  std::vector<int> myvector (2,200);        // vector with 2 elements  
  
  std::stack<int> first;                    // empty stack  
  std::stack<int> second (mydeque);         // stack initialized to copy of deque  
  
  std::stack<int,std::vector<int> > third;  // empty stack using vector  
  std::stack<int,std::vector<int> > fourth (myvector);  
  
  std::cout << "size of first: " << first.size() << '\n';  
  std::cout << "size of second: " << second.size() << '\n';  
  std::cout << "size of third: " << third.size() << '\n';  
  std::cout << "size of fourth: " << fourth.size() << '\n';  
  second.push(2);  
  std::cout << "The element at the top of stack second is: "  
        << second.top( ) << "." << std::endl;  
  std::cout << "size of second: " << second.size() << '\n';  
  
  return 0;  
}  

输出：

size of first: 0  
size of second: 3  
size of third: 0  
size of fourth: 2  
The element at the top of stack second is:2 .  
size of second: 4  

---

End