STL（七）：stack 与 queue

好久没有写过新的内容了。主要是最近真的没有时间。

好吧，这次介绍一下栈与队列的内容。

stack

先理一下之前写过的容器：

• vector
• deque
• list

这些都是序列式容器，但是使用了不同的数据结构来实现。

栈的特性，就是先进后出（或者后进先出）
一般来说，我们可以使用上面的容器来实现栈。

事实上，当你看到STL 中的设计时，才感叹，真是一种绝美的设计啊。

这次先从代码说起，它的全部代码都如下：

template<class T, class Sequence = deque<T> >class stack{    friend bool operator == (const stack& x, const stack& y);    friend bool operator < (const stack& x, const stack& y);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;//containerpublic:    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();    }    void swap(stack& x)    {        c.swap(x.c);    }};template<class T, class Sequence>bool operator == ( const stack<T, Sequence>& x, const stack<T, Sequence>& y){    return x.c == y.c;}template<class T, class Sequence>bool operator < (const stack<T, Sequence>& x, const stack<T, Sequence>& y){    return x.c < y.c;}template<class T, class Sequence>void swap(stack<T, Sequence>& x, stack<T, Sequence>& y){    x.swap(y。。;}

代码并不长。
stack 接受两个模板参数，一个是元素的类型，另一个是底层实现的容器。

看命名，其实我们就能够知道，它接受一个序列式容器。
这个序列式容器，在承诺上应该提供以下接口：

• push_back
• back
• size
• empty
• pop_back

看到这里，也许你就能明白为什么vector 的push 接口非得带个back 了。

一个规范的接口命名真的太重要了。

废话有点多，下面说说queue。

queue

其实这个也是一个用底层容器来实现主要功能的类。
队列的规则是 先进先出（或者后进后出）

序列式容器中的 deque 就很适合这个实现。

所以，它的代码如下：

template<class T, class Sequence = deque<T> >class queue{    friend bool operator == (const queue& x, const queue& y);    friend bool operator < (const queue& x, const queue& y);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:    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(); }    void push(const value_type& x)    {        c.push_back(x);    }    void pop()    {        c.pop_front();    }    void swap(queue& x)    {        c.swap(x.c);    }};template<class T, class Sequence>bool  operator == (const queue<T, Sequence>& x, const queue<T, Sequence>& y){    return x.c == y.c;}template<class T, class Sequence>bool operator < (const queue<T, Sequence>& x, const queue<T, Sequence>& y){    return x.c < y.c;}template<class T, class Sequence>void swap(queue<T, Sequence>& x, queue<T, Sequence>& y){    x.swap(y);}

也是很简单的一种实现。
过目就好。

它们没有迭代器

像是stack 和 queue 这种修改底层类的接口，从而达到自己类想要的功能，称之为配接器（adapter）

所以，它们是没有迭代器的概念的。

如果开心的话，你也可以实现一个类，按照规定，提供接口给它们，你就可以设计成自己的stack 和 queue 类的。