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;//container

public:
    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, sta
ck<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 类的。