C++ STL学习之五:配接器stack深入学习

最新推荐文章于 2023-05-14 22:39:34 发布

燕凌姣

最新推荐文章于 2023-05-14 22:39:34 发布

阅读量604

点赞数

分类专栏： STL 文章标签： STL

本文链接：https://blog.csdn.net/nedushy123/article/details/36419825

版权

STL 专栏收录该内容

9 篇文章 0 订阅

订阅专栏

stack是一种先进先出的数据结构。只能在栈顶操作。它以底层容器deque完成所有的操作，因此是一个adapter（配接器）。

不支持任一种迭代器，不支持遍历，它们都是容器适配器类型，stack是用vector/deque/list对象创建了一个先进后出容器。

示例程序

#include<iostream>
#include<vector>
#include<list>
#include<stack>
using namespace std;
int main(int argc,char *argv[])
{
	stack<int,list<int> > mystack;
	for(int i=10;i<20;i++)
		mystack.push(i);
	while(!mystack.empty())
	{
		cout<<mystack.top()<<" ";
		mystack.pop();
	}
	cout<<endl;
	return 0;
}

shenhuayu@shenhuayu-VirtualBox ~/src $ g++ stltest.cpp -g -o mystltest
shenhuayu@shenhuayu-VirtualBox ~/src $ ./mystltest
19 18 17 16 15 14 13 12 11 10

#ifndef __SGI_STL_INTERNAL_STACK_H
#define __SGI_STL_INTERNAL_STACK_H
#include <sequence_concepts.h>
__STL_BEGIN_NAMESPACE
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 {
  __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:
  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;
public:
  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 */