Standard library header <queue>

This header is part of the containers library.

Includes
`<initializer_list>`(C++11)
Classes
queue	adapts a container to provide queue (FIFO data structure) (class template)
priority_queue	adapts a container to provide priority queue (class template)
std::uses_allocator<std::queue> (C++11)	specializes the `std::uses_allocator` type trait (function template)
std::uses_allocator<std::priority_queue> (C++11)	specializes the `std::uses_allocator` type trait (function template)
Functions
operator==operator!=operator<operator<=operator>operator>=	lexicographically compares the values in the queue (function template)
std::swap(std::queue)	specializes the `std::swap` algorithm (function template)
std::swap(std::priority_queue)	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);
    }
};

© cppreference.com
Licensed under the Creative Commons Attribution-ShareAlike Unported License v3.0.
http://en.cppreference.com/w/cpp/header/queue

Standard library header <queue>

Includes

Classes

Functions

Synopsis

Class std::queue

Class std::priority_queue

Class `std::queue`

Class `std::priority_queue`