Stack和Queue

stack

stack是一种先进后出（First in last out, FILO）的数据结构，他只有一个出口。

以某种既有容器作为底部结构，将其接口改变，使之符合“先进后出”的特性，形成一个stack，很容易做到。deque是双向开口的数据结构，若以deque为底部结构并封闭其头端开口，便轻而易举地形成一个stack。因此，SGI STL便以deque作为缺省情况下的stack底部结构。

由于stack以底部容器完成其所有工作，而具有这种“修改某物接口，形成另一种风貌”的性质者，称为adapter(配接器)，因此，STL stack往往不被归类为container容器，而被归类为container adapter。

template<class T, class Sequence = deque<T>>
class stack{
    friend bool operator==__STL_NULL_TMPL_ARGS(const stack&, const stack&);
    friend bool operator<__STL_NULL_TMPL_ARGS(const stack&, const stack&);
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 top() { return c.back(); }
    const_reference top() const { return c.back(); }
    //deque是两头可进出，stack是末端进，末端出
    void push(const value_type& x) { c.push_back(x); }
    void pop() { c.pop_back(); }
};
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;
}

stack不提供走访功能，也不提供迭代器。

queue

queue是一种先进先出（First in first Out, fifo）的数据结构。它有两个出口。queue允许新增元素，移除元素，从最低端加入元素，取得最顶端元素。但除了最底端可以加入，最顶端可以取出外，没有任何其他方法可以存取queue的其他元素。换言之，queue不允许有遍历行为。

以某种既有容器为底部结构，将其接口改变，使其符合“先进先出”的特性，形成一个queue，是很容易做到的。deque是双向开口的数据结构，若以deque为底部结构并封闭其底端的出口和前端的入口，便轻而易举的形成了一个queue。因此，SGI STL便以deque作为缺省情况下的queue底部结构。

由于queue以底部容器完成其所有工作，而具有这种“修改某物接口，形成另一种风貌”的性质者，称为adapter（配接器），因此，STL queue往往不被归类为container容器，而被归类为container adapter。

template <class T, class Sequence = deque<T> >
class queue{
	friend bool operator==__STL_NULL_TMPL_ARGS(const queue& x, const queue& y);
    friend bool operator<__STL_NULL_TMPL_ARGS(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(); }
    reference back() { return c.back(); }
    const_reference back() const { return c.back(); }
    
    //deque是两头可进出的，queue是末端进，前端出
    void push(const value_type& x) { c.push_back(x); }
    void pop(){ c.pop_front(); }
};
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;
}

queue所有元素的进出都必须符合“先进先出”的条件，只有queue顶端的元素，才有机会被外界取用。queue不提供遍历功能，也不提供迭代器。