标准库头文件 <queue>

C++ 参考手册

位置：首页 > C++ 参考手册 >C++ 标准库头文件 > 标准库头文件 <queue>

此头文件是容器库的一部分。

包含
`<initializer_list>`(C++11)
类
queue	适配一个容器以提供队列（FIFO 数据结构） (类模板)
priority_queue	适配一个容器以提供优先级队列 (类模板)
std::uses_allocator<std::queue> (C++11)	特化 std::uses_allocator 类型特性 (函数模板)
std::uses_allocator<std::priority_queue> (C++11)	特化 std::uses_allocator 类型特性 (函数模板)
函数
operator==operator!=operator<operator<=operator>operator>=operator<=> (C++20 中移除)(C++20 中移除)(C++20 中移除)(C++20 中移除)(C++20 中移除)(C++20)	按照字典顺序比较 queue 中的值 (函数模板)
std::swap(std::queue)	特化 std::swap 算法 (函数模板)
std::swap(std::priority_queue)	特化 std::swap 算法 (函数模板)

概要

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

类 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);
    }
};

类 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);
    }
};

C++ 参考手册

标准库头文件 <queue>

包含

类

函数

概要

类 std::queue

类 std::priority_queue