STL之stack

栈，LIFO的数据结构。

template <typename T, typename Container = deque<T> > class stack;

stack是一个容器适配器，数据从容器的一端插入和取出（称为top端）。内部有一个Container类型的private变量，用来存储数据。

容器只要支持如下操作即可作为stack的内部容器：

empty()、size()、back()、push_back()、pop_back()

vector，deque，list都满足要求，默认使用的是deque。

根据标准，stack有3个成员类型：

value_type      第一个模板参数     栈元素的类型
container_type  第二个模板参数     栈内部容器的类型
size_type       一个无符号整型     通常是size_t类型

stack还有一些成员函数，它们都是public的：

explicit stack (const container_type& ctnr = container_type());
参数类型须和第二个模板参数相同

bool empty() const;
判断stack是否为空，即size是否为0，调用内部容器的empty()

size_type size() const;
调用内部容器的size()

value_type& top();
const value_type& top() const;
返回顶部元素，调用内部容器的back()

void push (const value_type& val);
插入一个元素，被初始化为val的拷贝，调用内部容器的push_back()

void pop();
移除顶部元素，会调用移除元素的析构函数，调用内部容器的pop_back()

此外，stack还有一些关系操作符，它们都是模板函数。（lhs=the left-hand side）

template <class T, class Container>
bool operator== (const stack<T,Container>& lhs, const stack<T,Container>& rhs);
template <class T, class Container>
bool operator!= (const stack<T,Container>& lhs, const stack<T,Container>& rhs);
template <class T, class Container>
bool operator<  (const stack<T,Container>& lhs, const stack<T,Container>& rhs);
template <class T, class Container>
bool operator<= (const stack<T,Container>& lhs, const stack<T,Container>& rhs);
template <class T, class Container>
bool operator>  (const stack<T,Container>& lhs, const stack<T,Container>& rhs);
template <class T, class Container>
bool operator>= (const stack<T,Container>& lhs, const stack<T,Container>& rhs);

下面是stack的完整源代码（stl_stack.h）：

// operator==和operator<的前向声明对于友元的声明是必须的
// stack的前向声明对于operator==和operator<的声明是必须的
template <typename _Tp, typename _Sequence = deque<_Tp> >
class stack;

template <typename _Tp, typename _Seq>
bool operator==(const stack<_Tp,_Seq>& __x, const stack<_Tp,_Seq>& __y);
template <typename _Tp, typename _Seq>
bool operator<(const stack<_Tp,_Seq>& __x, const stack<_Tp,_Seq>& __y);

template <typename _Tp, typename _Sequence>
class stack
{
    template <typename _Tp1, typename _Seq1>
    friend bool operator== (const stack<_Tp1, _Seq1>&, const stack<_Tp1, _Seq1>&);
    template <typename _Tp1, typename _Seq1>
    friend bool operator< (const stack<_Tp1, _Seq1>&, const stack<_Tp1, _Seq1>&);

public:
    typedef typename _Sequence::value_type      value_type;
    typedef typename _Sequence::size_type       size_type;
    typedef           _Sequence                  container_type;

    typedef typename _Sequence::reference       reference;
    typedef typename _Sequence::const_reference const_reference;

protected:
    _Sequence c;

public:
    stack() : c() {}
    explicit stack(const _Sequence& __s) : c(__s) {}
    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(); }
};

template <typename _Tp, typename _Seq>
bool operator==(const stack<_Tp,_Seq>& __x, const stack<_Tp,_Seq>& __y)
{
    return __x.c == __y.c;
}

template <typename _Tp, typename _Seq>
bool operator<(const stack<_Tp,_Seq>& __x, const stack<_Tp,_Seq>& __y)
{
    return __x.c < __y.c;
}

template <typename _Tp, typename _Seq>
bool operator!=(const stack<_Tp,_Seq>& __x, const stack<_Tp,_Seq>& __y)
{
    return !(__x == __y);
}

template <typename _Tp, typename _Seq>
bool operator>(const stack<_Tp,_Seq>& __x, const stack<_Tp,_Seq>& __y)
{
    return __y < __x;
}

template <typename _Tp, typename _Seq>
bool operator<=(const stack<_Tp,_Seq>& __x, const stack<_Tp,_Seq>& __y)
{
    return !(__y < __x);
}

template <typename _Tp, typename _Seq>
bool operator>=(const stack<_Tp,_Seq>& __x, const stack<_Tp,_Seq>& __y)
{
    return !(__x < __y);
}