`<stack>`

Include the STL standard header <stack> to define the template class stack and several supporting templates.

namespace std {
template<class Ty, class Container>
    class stack;

        // TEMPLATE FUNCTIONS
template<class Ty, class Container>
    bool operator==(const stack<Ty, Container>& left,
        const stack<Ty, Container>& right);
template<class Ty, class Container>
    bool operator!=(const stack<Ty, Container>& left,
        const stack<Ty, Container>& right);
template<class Ty, class Container>
    bool operator<(const stack<Ty, Container>& left,
        const stack<Ty, Container>& right);
template<class Ty, class Container>
    bool operator>(const stack<Ty, Container>& left,
        const stack<Ty, Container>& right);
template<class Ty, class Container>
    bool operator<=(const stack<Ty, Container>& left,
        const stack<Ty, Container>& right);
template<class Ty, class Container>
    bool operator>=(const stack<Ty, Container>& left,
        const stack<Ty, Container>& right);
}  // namespace std

`operator!=`

template<class Ty, class Container>
    bool operator!=(const stack <Ty, Container>& left,
        const stack <Ty, Container>& right);

The template function returns !(left == right).

`operator==`

template<class Ty, class Container>
    bool operator==(const stack <Ty, Container>& left,
        const stack <Ty, Container>& right);

The template function overloads operator== to compare two objects of template class stack. The function returns left.c == right.c.

`operator<`

template<class Ty, class Container>
    bool operator<(const stack <Ty, Container>& left,
        const stack <Ty, Container>& right);

The template function overloads operator< to compare two objects of template class stack. The function returns left.c < right.c.

`operator<=`

template<class Ty, class Container>
    bool operator<=(const stack <Ty, Container>& left,
        const stack <Ty, Container>& right);

The template function returns !(right < left).

`operator>`

template<class Ty, class Container>
    bool operator>(const stack <Ty, Container>& left,
        const stack <Ty, Container>& right);

The template function returns right < left.

`operator>=`

template<class Ty, class Container>
    bool operator>=(const stack <Ty, Container>& left,
        const stack <Ty, Container>& right);

The template function returns !(left < right).

`stack`

template<class Ty,
    class Container = deque<Ty> >
    class stack {
public:
    typedef Container container_type;
    typedef typename Container::value_type value_type;
    typedef typename Container::size_type size_type;
    typedef typename Container::reference reference;
    typedef typename Container::const_reference const_reference;
    stack();
    explicit stack(const container_type& cont);
    bool empty() const;
    size_type size() const;
    reference top();
    const_reference top() const;
    void push(const value_type& val);
    void pop();
protected:
    Container c;
    };

The template class describes an object that controls a varying-length sequence of elements. The object allocates and frees storage for the sequence it controls through a protected object named c, of class Container. The type Ty of elements in the controlled sequence must match value_type.

An object of class Container must supply several public members defined the same as for deque, list, and vector (all of which are suitable candidates for class Container). The required members are:

    typedef Ty value_type;
    typedef T0 size_type;
    typedef T1 reference;
    typedef T2 const_reference;
    Container();
    bool empty() const;
    size_type size() const;
    value_type& back();
    const value_type& back() const;
    void push_back(const value_type& val);
    void pop_back();
    bool operator==(const Container& cont) const;
    bool operator!=(const Container& cont) const;
    bool operator<(const Container& cont) const;
    bool operator>(const Container& cont) const;
    bool operator<=(const Container& cont) const;
    bool operator>=(const Container& cont) const;

Here, T0, T1, and T2 are unspecified types that meet the stated requirements.

`stack::const_reference`

typedef typename Container::const_reference const_reference;

The type is a synonym for Container::const_reference.

`stack::container_type`

typedef Container container_type;

The type is a synonym for the template parameter Container.

`stack::empty`

bool empty() const;

The member function returns true for an empty controlled sequence.

`stack::pop`

void pop();

The member function removes the last element of the controlled sequence, which must be non-empty.

`stack::push`

void push(const Ty& val);

The member function inserts an element with value val at the end of the controlled sequence.

`stack::reference`

typedef typename Container::reference reference;

The type is a synonym for Container::reference.

`stack::size`

size_type size() const;

The member function returns the length of the controlled sequence.

`stack::size_type`

typedef typename Container::size_type size_type;

The type is a synonym for Container::size_type.

`stack::stack`

stack();
explicit stack(const container_type& cont);

The first constructor initializes the stored object with c(), to specify an empty initial controlled sequence. The second constructor initializes the stored object with c(cont), to specify an initial controlled sequence that is a copy of the sequence controlled by cont.

`stack::top`

reference top();
const_reference top() const;

The member function returns a reference to the last element of the controlled sequence, which must be non-empty.

`stack::value_type`

typedef typename Container::value_type value_type;

The type is a synonym for Container::value_type.

See also the Table of Contents and the Index.