Archivo de encabezado de la biblioteca estándar <stack>

#include <initializer_list>
 
namespace std {
    template <typename T, typename Container = deque<T> > class stack;
 
    template <typename T, typename Container>
        bool operator==(const stack<T, Container>& x,const stack<T, Container>& y);
    template <typename T, typename Container>
        bool operator!=(const stack<T, Container>& x,const stack<T, Container>& y);
 
    template <typename T, typename Container>
        bool operator< (const stack<T, Container>& x,const stack<T, Container>& y);
    template <typename T, typename Container>
        bool operator> (const stack<T, Container>& x,const stack<T, Container>& y);
    template <typename T, typename Container>
        bool operator>=(const stack<T, Container>& x,const stack<T, Container>& y);
    template <typename T, typename Container>
        bool operator<=(const stack<T, Container>& x,const stack<T, Container>& y);
 
    template <typename T, typename Container>
        void swap(stack<T, Container>& x, stack<T, Container>& y)
            noexcept(noexcept(x.swap(y)));
 
    template <typename T, typename Container, typename Alloc>
        struct uses_allocator<stack<T, Container>, Alloc> :
             uses_allocator<Container, Alloc>::type { };
}

template <typename T, typename Container = std::deque<T> >
class stack {
 public:
    typedef typename Container::value_type value_type;
    typedef typename Container::reference reference;
    typedef typename Container::const_reference const_reference;
    typedef typename Container::size_type size_type;
    typedef Container container_type;
 
 protected:
    Container c;
 
 public:
    explicit stack(const Container&);
    explicit stack(Container&& = Container());
    template <typename Alloc> explicit stack(const Alloc&);
    template <typename Alloc> stack(const Container&, const Alloc&);
    template <typename Alloc> stack(Container&&, const Alloc&);
    template <typename Alloc> stack(const stack&, const Alloc&);
    template <typename Alloc> stack(stack&&, const Alloc&);
 
    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 push(value_type&& x) {
        c.push_back(std::move(x));
    }
    template <typename... Args> void emplace(Args&&... args) {
        c.emplace_back(std::forward<Args>(args)...);
    }
    void pop() {
        c.pop_back();
    }
    void swap(stack& s) noexcept(noexcept(swap(c, s.c))) {
        using std::swap;
        swap(c, s.c);
    }
};