C++ STL 的堆栈泛化是直接通过现有的序列容器来实现的,默认使用双端队列deque的数据结构,当然,可以采用其他线性结构(vector 或 list等),只要提供堆栈的入栈、出栈、栈顶元素访问和判断是否为空的操作即可。由于堆栈的底层使用的是其他容器,因此,堆栈可看做是一种适配器,将一种容器转换为另一种容器(堆栈容器)。
stack堆栈容器的C++标准头文件为 stack ,必须用宏语句 "#include <stack>" 包含进来,才可对 stack 堆栈的程序进行编译。
一、stack的三种模板
- #if !defined ( _STLP_LIMITED_DEFAULT_TEMPLATES )
- template <class _Tp, class _Sequence = deque<_Tp> >
- #elif defined ( _STLP_MINIMUM_DEFAULT_TEMPLATE_PARAMS )
- # define _STLP_STACK_ARGS _Tp
- template <class _Tp>
- #else
- template <class _Tp, class _Sequence>
- #endif
- 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 不同的地方。
实例:
- // test_stack.cpp : 定义控制台应用程序的入口点。
- //
- #include "stdafx.h"
- #include <stack>
- #include <vector>
- #include <deque>
- #include <iostream>
- using namespace std;
- int _tmain(int argc, _TCHAR* argv[])
- {
- deque<int> mydeque(2,100);
- vector<int> myvector(2,200);
- stack<int> first;
- stack<int> second(mydeque); //默认使用deque做容器
- stack<int,vector<int> > third;
- stack<int,vector<int> > fourth(myvector);
- cout << "size of first: " << (int) first.size() << endl;
- cout << "size of second: " << (int) second.size() << endl;
- cout << "size of third: " << (int) third.size() << endl;
- cout << "size of fourth: " << (int) fourth.size() << endl;
- return 0;
- }
三、元素操作
1.元素入栈(栈顶):void push(const value_type& __x) { c.push_back(__x); }
stack堆栈容器的元素入栈函数为 push 函数。由于 C++ STL 的堆栈函数是不预设大小的,因此,入栈函数就不考虑堆栈空间是否为满,均将元素压入堆栈,从而函数没有标明入栈成功与否的返回值。
- // stack::push/pop
- #include <iostream>
- #include <stack>
- using namespace std;
- int main ()
- {
- stack<int> mystack;
- for (int i=0; i<5; ++i) mystack.push(i);
- cout << "Popping out elements...";
- while (!mystack.empty())
- {
- cout << " " << mystack.top();
- mystack.pop();
- }
- cout << endl;
- return 0;
- }
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.访问栈顶元素
- reference top() { return c.back(); }
- const_reference top() const { return c.back(); }
4.堆栈判空
- bool empty() const { return c.empty(); }
判断堆栈是否为空,返回 true 表示堆栈已空,false 表示堆栈非空。
5.栈的大小
- size_type size() const { return c.size(); }
// 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
1. 定义“方便”宏
- #ifndef _STLP_STACK_ARGS
- # define _STLP_STACK_ARGS _Tp, _Sequence
- # define _STLP_STACK_HEADER_ARGS class _Tp, class _Sequence
- #else
- # define _STLP_STACK_HEADER_ARGS class _Tp
- #endif
- template < _STLP_STACK_HEADER_ARGS >
- inline bool _STLP_CALL operator<(const stack< _STLP_STACK_ARGS >& __x,
- const stack< _STLP_STACK_ARGS >& __y)
- { return __x._Get_s() < __y._Get_s(); }
(1) 声明为inline。因为函数较短,适用(内联会在任何被调用的地方展开);
(2) 参数声明为常量引用。因为传入的参数可能很大,如果普通传参会复制个副本,浪费内存。
3. 重载==操作符
- template < _STLP_STACK_HEADER_ARGS >
- inline bool _STLP_CALL operator==(const stack< _STLP_STACK_ARGS >& __x,
- const stack< _STLP_STACK_ARGS >& __y)
- { 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); |
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的全部特性)。