STL stack

  堆栈是一个线性表，插入和删除只在表的一端进行。这一端称为栈顶(Stack Top)，另一端则为栈底(Stack Bottom)。堆栈的元素插入称为入栈，元素的删除称为出栈。由于元素的入栈和出栈总在栈顶进行，因此，堆栈是一个后进先出(Last In First Out)表，即 LIFO 表。为了严格遵循堆栈的数据后进先出原则，stack 不提供元素的任何迭代器操作，因此，stack 容器也就不会向外部提供可用的前向或反向迭代器类型。

    C++ STL 的堆栈泛化是直接通过现有的序列容器来实现的，默认使用双端队列deque的数据结构，当然，可以采用其他线性结构（vector 或 list等），只要提供堆栈的入栈、出栈、栈顶元素访问和判断是否为空的操作即可。由于堆栈的底层使用的是其他容器，因此，堆栈可看做是一种适配器，将一种容器转换为另一种容器(堆栈容器)。

       stack堆栈容器的C++标准头文件为 stack ，必须用宏语句 "#include <stack>" 包含进来，才可对 stack 堆栈的程序进行编译。

一、stack的三种模板

1. #if !defined ( _STLP_LIMITED_DEFAULT_TEMPLATES )  
2. template <class _Tp, class _Sequence = deque<_Tp> >  
3. #elif defined ( _STLP_MINIMUM_DEFAULT_TEMPLATE_PARAMS )  
4. #  define _STLP_STACK_ARGS _Tp  
5. template <class _Tp>  
6. #else  
7. template <class _Tp, class _Sequence>  
8. #endif  

默认模板是：

1. template <class _Tp, class _Sequence = deque<_Tp> >  

第一个模板参数表示元素的类型，第二个模板参数表明了实现堆栈所使用的容器，即内部用于存储元素的容器，默认使用 deque（双端队列），你可以使用任何的序列容器，甚至于自己提供的顺序容器，只要含有 back(), push_back(), pop_back() 方法即可。

   

 为什么大多数STL的stack的实现中,对于内部的容器默认选择deque容器？而不是vector？  （参见http://blog.csdn.net/housisong/article/details/505254）

STL中，stack对内部使用容器的函数调用主要有：push_back,back，pop_back等，也就是顺序容器都满足要求(包括vector，deque,list)。很多人应该和我一样，在STL之前看到的stack实现都是以动态数组来(甚至静态数组)实现为主，也就是接近于使用vector方案；那为什么STL偏偏选择deque呢!?
    我的分析:
    a.用vector实现中(push_back动作为分期摊还常数时间)，如果发生容器的大小改变时，将可能产生一个大动作(申请空间，拷贝构造，释放原来的元素和空间，该动作成线性复杂度) 而且vector的很多实现版本中，容器在任何情况下都从不缩减已经申请的空间容量(swap技巧除外)； 
    b.用deque实现时，容器的大小改变时(数据量较大)，动作比vector就小多了（常数复杂度），并且当容器的大小变小时，还可以适当减小容量；但push_back 的逻辑相对vector复杂一点；
    c.用list实现时，不用考虑空间容量变化；但每次的压入弹出开销(内存时间)较大，但很平稳；那么，经过分析，在不同的应用场合，为stack选择不同的内部容器是很有必要的；如果对stack有性能上的要求，就应该考虑这一点(甚至重新写一个最适应问题要求的stack); 比如：要求有最快的平均访问速度，而且大概的容量要求也清楚(比较衡定)，那么，使用vector是个不错的选择 要求每次的访问时间平稳，而不在乎平均访问时间时，那么，可以考虑使用list；所以，库默认的deque是个不错的选择，它介于vector和list之间，并且很好的综合了两者的优势；另papercrane：“oncrete policy deque相对于stack来说就像傻瓜机，乱用也不会有什么太大的问题。如你所说的平均时间和最差时间的要求，我觉得就好像hash map和tree map的性能差别一样。 ”

二、创建 stack 对象

1.默认构造函数，创建一个空的 stack 对象。 stack（）

例如，使用默认的 底层容器deque，创建一个空的堆栈对象 s 。

    stack<int>  s;

2.复制构造函数，用一个stack堆栈创建一个新的堆栈。  stack(const stack&)

例如：下面的代码利用 s1 ，创建一个以双向链表为底层容器的空堆栈对象 s2 。
     stack<int, list<int> >   s1;
    stack<int, list<int> >   s2(s1);

3.使用其他容器保存元素

如：std::stack<int, std::vector<int> > st2; 

这里提及一下 deque，对于 deque，元素被移除的时候，释放内存，而且在重新分配内存（realloc）的时候，不会拷贝元素，这是与 vector 不同的地方。

实例：

1. // test_stack.cpp : 定义控制台应用程序的入口点。  
2. //   
3. #include "stdafx.h"  
4. #include <stack>  
5. #include <vector>  
6. #include <deque>  
7. #include <iostream>  
8.   
9. using namespace std;  
10.   
11. int _tmain(int argc, _TCHAR* argv[])  
12. {  
13.     deque<int> mydeque(2,100);  
14.     vector<int> myvector(2,200);  
15.   
16.     stack<int> first;  
17.     stack<int> second(mydeque);  //默认使用deque做容器
18.   
19.     stack<int,vector<int> > third;  
20.     stack<int,vector<int> > fourth(myvector);  
21.   
22.     cout << "size of first: " << (int) first.size() << endl;  
23.     cout << "size of second: " << (int) second.size() << endl;  
24.     cout << "size of third: " << (int) third.size() << endl;  
25.     cout << "size of fourth: " << (int) fourth.size() << endl;  
26.   
27.   
28.     return 0;  
29. }  

三、元素操作

1.元素入栈（栈顶）：void push(const value_type& __x) { c.push_back(__x); } 

          stack堆栈容器的元素入栈函数为 push 函数。由于 C++ STL 的堆栈函数是不预设大小的，因此，入栈函数就不考虑堆栈空间是否为满，均将元素压入堆栈，从而函数没有标明入栈成功与否的返回值。 

1. // stack::push/pop  
2. #include <iostream>  
3. #include <stack>  
4. using namespace std;  
5.   
6. int main ()  
7. {  
8.   stack<int> mystack;  
9.   
10.   for (int i=0; i<5; ++i) mystack.push(i);  
11.   
12.   cout << "Popping out elements...";  
13.   while (!mystack.empty())  
14.   {  
15.      cout << " " << mystack.top();  
16.      mystack.pop();  
17.   }  
18.   cout << endl;  
19.   
20.   return 0;  
21. }  

2.元素出栈（在栈顶删除元素）

void pop() { c.pop_back(); }  

stack容器的元素出栈函数为 pop 函数，由于函数并没有判断堆栈是否为空，就进行元素的弹出，因此，需要自行判断堆栈是否为空，才可执行 pop 函数。

下面的示例代码，将堆栈的所有元素全部出栈
    stack<int>  s;

     for (int i=0; i<5; ++i) stack.push(i);  
    while(!s.empty())
    { 
        s.pop();// 出栈
    }

3.访问栈顶元素

1. reference top() { return c.back(); }  
2. const_reference top() const { return c.back(); }  

4.堆栈判空

1. bool empty() const { return c.empty(); }  

  随着堆栈元素不断出栈，堆栈可能会出现空的情况，因此，一般需要调用 empty 函数判断是否非空，才作元素出栈和取栈顶元素的操作。

   判断堆栈是否为空，返回 true 表示堆栈已空，false 表示堆栈非空。

5.栈的大小

1. size_type size() const { return c.size(); }  

6.交换内容

void swap(stack& x)

// stack::swap
#include <iostream>       // std::cout
#include <stack>          // std::stack

int main ()
{
  std::stack<int> foo,bar;
  foo.push (10); foo.push(20); foo.push(30);
  bar.push (111); bar.push(222);

  foo.swap(bar);

  std::cout << "size of foo: " << foo.size() << '\n';
  std::cout << "size of bar: " << bar.size() << '\n';

  return 0;
}

输出：

size of foo: 2
size of bar: 3

四、重载操作符（针对栈的）参考http://blog.csdn.net/sophistcxf/article/details/9207327

1. 定义“方便”宏

[cpp]  view plain copy

1. #ifndef _STLP_STACK_ARGS  
2. #  define _STLP_STACK_ARGS _Tp, _Sequence  
3. #  define _STLP_STACK_HEADER_ARGS class _Tp, class _Sequence  
4. #else  
5. #  define _STLP_STACK_HEADER_ARGS class _Tp  
6. #endif  

2. 重载<操作符

[cpp]  view plain copy

1. template < _STLP_STACK_HEADER_ARGS >  
2. inline bool _STLP_CALL  operator<(const stack< _STLP_STACK_ARGS >& __x,  
3.                                   const stack< _STLP_STACK_ARGS >& __y)  
4. { return __x._Get_s() < __y._Get_s(); }  

注意几点（此后不再说明）：

（1） 声明为inline。因为函数较短，适用（内联会在任何被调用的地方展开）；

（2） 参数声明为常量引用。因为传入的参数可能很大，如果普通传参会复制个副本，浪费内存。

3. 重载==操作符

[cpp]  view plain copy

1. template < _STLP_STACK_HEADER_ARGS >  
2. inline bool _STLP_CALL  operator==(const stack< _STLP_STACK_ARGS >& __x,  
3.                                    const stack< _STLP_STACK_ARGS >& __y)  
4. { return __x._Get_s() == __y._Get_s(); }  

比较操作符都依赖于Sequence（即deque）的比较操作符。

4. 比较操作符

包括 ==, <=, >=, !=, <, >

两个栈相等的含义是，栈中元素数目，以及对应位置的元素相等

(1)	template <class T, class Container> bool operator== (const stack<T,Container>& lhs, const stack<T,Container>& rhs);
(2)	template <class T, class Container> bool operator!= (const stack<T,Container>& lhs, const stack<T,Container>& rhs);
(3)	template <class T, class Container> bool operator< (const stack<T,Container>& lhs, const stack<T,Container>& rhs);
(4)	template <class T, class Container> bool operator<= (const stack<T,Container>& lhs, const stack<T,Container>& rhs);
(5)	template <class T, class Container> bool operator> (const stack<T,Container>& lhs, const stack<T,Container>& rhs);
(6)	template <class T, class Container> bool operator>= (const stack<T,Container>& lhs, const stack<T,Container>& rhs);

Performs the appropriate comparison operation between  lhs  and  rhs .

Each of these operator overloads calls the same operator on the  underlying container  objects.

五、总结

     堆栈是一种应用非常广泛的数据结构。C++ STL 将这种数据结构和它若干受限制操作用泛型类 stack 容器封装出来，包括堆栈初始化、元素入栈、取栈顶元素、元素出栈、判断堆栈是否非空和取得当前堆栈大小等，应用起来十分容易。

      stack实际上并没有多少自已的逻辑，几乎完全依赖于deque。在实现上，好像也可能用stack作为deque的子类来实现，为什么不这样而采用模板的形式呢？可能是因为，deque还提供了许多stack并不需要的方法，这违背面向对象的原则，stack并非是deque的子类（没有deque的全部特性）。