# 标准库头文件 <queue>

< cpp‎ | header

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

### 包含
<compare> (C++20) | 三路比较运算符支持
<initializer_list> (C++11) | std::initializer_list 类模板
### 类
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) | 按照字典顺序比较 queue 中的值 (函数模板)
std::swap(std::queue) (C++11) | 特化 std::swap 算法 (函数模板)
std::swap(std::priority_queue) (C++11) | 特化 std::swap 算法 (函数模板)

### 概要

    #include <compare>
    #include <initializer_list>

    namespace std {
      template<class T, class Container = deque<T>> class 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, three_way_comparable Container>
        compare_three_way_result_t<Container>
          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 Alloc>
        struct uses_allocator<queue<T, Container>, Alloc>;

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

      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 Compare, class Alloc>
        struct uses_allocator<priority_queue<T, Container, Compare>, Alloc>;
    }

#### 类模板 std::queue

    namespace std {
      template<class T, class Container = deque<T>>
      class queue {
      public:
        using value_type      = typename Container::value_type;
        using reference       = typename Container::reference;
        using const_reference = typename Container::const_reference;
        using size_type       = typename Container::size_type;
        using container_type  =          Container;

      protected:
        Container c;

      public:
        queue() : queue(Container()) {}
        explicit queue(const Container&);
        explicit queue(Container&&);
        template<class InputIt> queue(InputIt first, InputIt last);
        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&);
        template<class InputIt, class Alloc>
          queue(InputIt first, InputIt last, const Alloc&);

        [[nodiscard]] 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>
          decltype(auto) emplace(Args&&... args)
            { return c.emplace_back(std::forward<Args>(args)...); }
        void pop()                          { c.pop_front(); }
        void swap(queue& q) noexcept(is_nothrow_swappable_v<Container>)
          { using std::swap; swap(c, q.c); }
      };

      template<class Container>
        queue(Container) -> queue<typename Container::value_type, Container>;

      template<class InputIt>
        queue(InputIt, InputIt) -> queue</*iter-value-type*/<InputIt>>;

      template<class Container, class Allocator>
        queue(Container, Allocator) -> queue<typename Container::value_type, Container>;

      template<class InputIt, class Allocator>
        queue(InputIt, InputIt, Allocator)
          -> queue</*iter-value-type*/<InputIt>, deque</*iter-value-type*/<InputIt>,
                   Allocator>>;

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

#### 类模板 std::priority_queue

    namespace std {
      template<class T, class Container = vector<T>,
               class Compare = less<typename Container::value_type>>
      class priority_queue {
      public:
        using value_type      = typename Container::value_type;
        using reference       = typename Container::reference;
        using const_reference = typename Container::const_reference;
        using size_type       = typename Container::size_type;
        using container_type  = Container;
        using value_compare   = Compare;

      protected:
        Container c;
        Compare comp;

      public:
        priority_queue() : priority_queue(Compare()) {}
        explicit priority_queue(const Compare& x) : priority_queue(x, Container()) {}
        priority_queue(const Compare& x, const Container&);
        priority_queue(const Compare& x, Container&&);
        template<class InputIt>
          priority_queue(InputIt first, InputIt last, const Compare& x = Compare());
        template<class InputIt>
          priority_queue(InputIt first, InputIt last, const Compare& x,
                         const Container&);
        template<class InputIt>
          priority_queue(InputIt first, InputIt last, const Compare& x,
                         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&);
        template<class InputIt, class Alloc>
          priority_queue(InputIt, InputIt, const Alloc&);
        template<class InputIt, class Alloc>
          priority_queue(InputIt, InputIt, const Compare&, const Alloc&);
        template<class InputIt, class Alloc>
          priority_queue(InputIt, InputIt, const Compare&, const Container&,
                         const Alloc&);
        template<class InputIt, class Alloc>
          priority_queue(InputIt, InputIt, const Compare&, Container&&, const Alloc&);

        [[nodiscard]] 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(is_nothrow_swappable_v<Container> &&
                                              is_nothrow_swappable_v<Compare>)
          { using std::swap; swap(c, q.c); swap(comp, q.comp); }
      };

      template<class Compare, class Container>
        priority_queue(Compare, Container)
          -> priority_queue<typename Container::value_type, Container, Compare>;

      template<class InputIt,
               class Compare = less</*iter-value-type*/<InputIt>>,
               class Container = vector</*iter-value-type*/<InputIt>>>
        priority_queue(InputIt, InputIt, Compare = Compare(), Container = Container())
          -> priority_queue</*iter-value-type*/<InputIt>, Container, Compare>;

      template<class Compare, class Container, class Allocator>
        priority_queue(Compare, Container, Allocator)
          -> priority_queue<typename Container::value_type, Container, Compare>;

      template<class InputIt, class Allocator>
        priority_queue(InputIt, InputIt, Allocator)
          -> priority_queue</*iter-value-type*/<InputIt>,
                            vector</*iter-value-type*/<InputIt>, Allocator>,
                            less</*iter-value-type*/<InputIt>>>;

      template<class InputIt, class Compare, class Allocator>
        priority_queue(InputIt, InputIt, Compare, Allocator)
          -> priority_queue</*iter-value-type*/<InputIt>,
                            vector</*iter-value-type*/<InputIt>, Allocator>, Compare>;

      template<class InputIt, class Compare, class Container, class Allocator>
        priority_queue(InputIt, InputIt, Compare, Container, Allocator)
          -> priority_queue<typename Container::value_type, Container, Compare>;

      // 不提供相等

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