# <stack>

<head><title>&lt;stack&gt;</title></head>

# `<stack>`

* * *

Include the [STL](https://docs.qualcomm.com/doc/80-N3040-23/topic/cpp_index.html#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 stdCopy to clipboard

## `operator!=`

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

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

## `operator==`

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

The template function overloads `operator==` to compare
two objects of template class
[`stack`](https://docs.qualcomm.com/doc/80-N3040-23/topic/cpp_stack.html#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);Copy to clipboard

The template function overloads `operator<` to compare
two objects of template class
[`stack`](https://docs.qualcomm.com/doc/80-N3040-23/topic/cpp_stack.html#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);Copy to clipboard

The template function returns `!(right < left)`.

## `operator>`

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

The template function returns `right < left`.

## `operator>=`

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

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;
        };Copy to clipboard

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;Copy to clipboard

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

### `stack::const_reference`

    typedef typename Container::const_reference const_reference;Copy to clipboard

The type is a synonym for `Container::const_reference`.

### `stack::container_type`

    typedef Container container_type;Copy to clipboard

The type is a synonym for the template parameter `Container`.

### `stack::empty`

    bool empty() const;Copy to clipboard

The member function returns true for an empty controlled sequence.

### `stack::pop`

    void pop();Copy to clipboard

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

### `stack::push`

    void push(const Ty& val);Copy to clipboard

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

### `stack::reference`

    typedef typename Container::reference reference;Copy to clipboard

The type is a synonym for `Container::reference`.

### `stack::size`

    size_type size() const;Copy to clipboard

The member function returns the length of the controlled sequence.

### `stack::size_type`

    typedef typename Container::size_type size_type;Copy to clipboard

The type is a synonym for `Container::size_type`.

### `stack::stack`

    stack();
    explicit stack(const container_type& cont);Copy to clipboard

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;Copy to clipboard

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;Copy to clipboard

The type is a synonym for `Container::value_type`.

* * *

See also the
**[Table of Contents](https://docs.qualcomm.com/doc/80-N3040-23/topic/cpp_index.html#Table%20of%20Contents)** and the
**[Index](https://docs.qualcomm.com/doc/80-N3040-23/topic/_cpp_index.html)**.

*[Copyright](https://docs.qualcomm.com/doc/80-N3040-23/topic/cpp_crit_pjp.html) © 1992-2006by P.J. Plauger. Portions derived from work[copyright](https://docs.qualcomm.com/doc/80-N3040-23/topic/cpp_crit_hp.html) © 1994by Hewlett-Packard Company. All rights reserved.*

<!--V5.01:1566-->

Last Published: Oct 06, 2026

Previous Topic
 
<sstream></sstream> Next Topic

<stdarg.h></stdarg.h>