Standard library header <queue> - cppreference.com

##### cppreference.com

##### Search

Create account

##### Namespaces

- Page
- Discussion

##### Variants

##### Views

- View
- Edit
- History

##### Actions

# Standard library header <queue>

From cppreference.com
< cpp‎ | header

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) [edit]
priority_queue | adapts a container to provide priority queue (class template) [edit]
std::uses_allocator<std::queue> (C++11) | specializes the std::uses_allocator type trait (function template) [edit]
std::uses_allocator<std::priority_queue> (C++11) | specializes the std::uses_allocator type trait (function template) [edit]
### Functions
operator==operator!=operator<operator<=operator>operator>= | lexicographically compares the values in the queue (function template) [edit]
std::swap(std::queue) | specializes the std::swap algorithm (function template) [edit]
std::swap(std::priority_queue) | specializes the std::swap algorithm (function template) [edit]

### [edit] Synopsis

    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 { };

    }

#### [edit] 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);
        }
    };

#### [edit] 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);
        }
    };

Retrieved from "http://en.cppreference.com/mwiki/index.php?title=cpp/header/queue&oldid=63990"