Standard library header <queue>

From cppreference.com
< cpplrm; | header

This header is part of the containers library.

Includes

<initializer_list>(C++11)

Classes

adapts a container to provide queue (FIFO data structure)
(class template)
adapts a container to provide priority queue
(class template)
specializes the std::uses_allocator type trait
(function template)
specializes the std::uses_allocator type trait
(function template)

Functions

lexicographically compares the values in the queue
(function template)
specializes the std::swap algorithm
(function template)
specializes the std::swap algorithm
(function template)

Synopsis

#include <initializer_list>

namespace std {
    template <class T, class Container = deque<T> > class queue;

    template <class T,
              class Container = vector<T>,
              class Compare = less<typename Container::value_type> >
    class priority_queue;

    template <class T, class Container>
        bool operator==(const queue<T, Container>& x,const queue<T, Container>& y);
    template <class T, class Container>
        bool operator!=(const queue<T, Container>& x,const queue<T, Container>& y);

    template <class T, class Container>
        bool operator< (const queue<T, Container>& x,const queue<T, Container>& y);
    template <class T, class Container>
        bool operator> (const queue<T, Container>& x,const queue<T, Container>& y);
    template <class T, class Container>
        bool operator>=(const queue<T, Container>& x,const queue<T, Container>& y);
    template <class T, class Container>
        bool operator<=(const queue<T, Container>& x,const queue<T, Container>& y);

    template <class T, class Container>
        void swap(queue<T, Container>& x, queue<T, Container>& y)
            noexcept(noexcept(x.swap(y)));

    template <class T, class Container, class Compare>
        void swap(priority_queue<T, Container, Compare>& x,
                  priority_queue<T, Container, Compare>& y)
        noexcept(noexcept(x.swap(y)));

    template <class T, class Container, class Alloc>
        struct uses_allocator<queue<T, Container>, Alloc>
            : uses_allocator<Container, Alloc>::type { };

}

Class std::queue

template <class T, class Container = deque<T> >
class queue {
 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 queue(const Container&);
    explicit queue(Container&& = Container());
    template <class Alloc> explicit queue(const Alloc&);
    template <class Alloc> queue(const Container&, const Alloc&);
    template <class Alloc> queue(Container&&, const Alloc&);
    template <class Alloc> queue(const queue&, const Alloc&);
    template <class Alloc> queue(queue&&, const Alloc&);

    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();
    }
    void push(const value_type& x) {
        c.push_back(x);
    }
    void push(value_type&& x) {
        c.push_back(std::move(x));
    }
    template <class... Args> void emplace(Args&&... args) {
        c.emplace_back(std::forward<Args>(args)...);
    }
    void pop() {
        c.pop_front();
    }
    void swap(queue& q) noexcept(noexcept(swap(c, q.c))) {
        using std::swap;
        swap(c, q.c);
    }
};

Class std::priority_queue

template <class T,
          class Container = vector<T>,
          class Compare = less<typename Container::value_type> >
class priority_queue {
 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;
    Compare comp;
 public:
    priority_queue(const Compare& x, const Container&);
    explicit priority_queue(const Compare& x = Compare(), Container&& = Container());
    template <class InputIterator>
    priority_queue(InputIterator first, InputIterator last,
                       const Compare& x, const Container&);
    template <class InputIterator>
    priority_queue(InputIterator first, InputIterator last,
                   const Compare& x = Compare(), Container&& = Container());
    template <class Alloc> explicit priority_queue(const Alloc&);
    template <class Alloc> priority_queue(const Compare&, const Alloc&);
    template <class Alloc> priority_queue(const Compare&,
                                          const Container&, const Alloc&);
    template <class Alloc> priority_queue(const Compare&,
                                          Container&&, const Alloc&);
    template <class Alloc> priority_queue(const priority_queue&, const Alloc&);
    template <class Alloc> priority_queue(priority_queue&&, const Alloc&);

    bool empty() const {
        return c.empty();
    }
    size_type size() const {
        return c.size();
    }
    const_reference top() const {
        return c.front();
    }
    void push(const value_type& x);
    void push(value_type&& x);
    template <class... Args> void emplace(Args&&... args);
    void pop();
    void swap(priority_queue& q) noexcept( noexcept(swap(c, q.c))
                                        && noexcept(swap(comp, q.comp))) {
        using std::swap;
        swap(c, q.c);
        swap(comp, q.comp);
    }
};