Namespaces
Variants

Standard library header <queue>

From cppreference.net
C++
Standard library headers

Cet en-tête fait partie de la bibliothèque de conteneurs .

Table des matières

Inclusions

(C++20)
Opérateur de comparaison à trois voies support
(C++11)
std::initializer_list modèle de classe

Classes

adapte un conteneur pour fournir une file (structure de données FIFO)
(modèle de classe)
adapte un conteneur pour fournir une file de priorité
(modèle de classe)
(C++11)
spécialise le trait de type std::uses_allocator
(spécialisation de modèle de classe)
(C++11)
spécialise le trait de type std::uses_allocator
(spécialisation de modèle de classe)

Fonctions

(C++20)
compare lexicographiquement les valeurs de deux queue s
(modèle de fonction)
(C++11)
spécialise l'algorithme std::swap
(modèle de fonction)
(C++11)
spécialise l'algorithme std::swap
(modèle de fonction)

Synopsis 

#include <compare>
#include <initializer_list>
namespace std {
  // modèle de classe queue
  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>;
  // spécialisation formatter pour queue
  template<class CharT, class T, formattable<CharT> Container>
  struct formatter<queue<T, Container>, CharT>;
  // modèle de classe priority_queue
  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>;
  // spécialisation formatter pour priority_queue
  template<class CharT, class T, formattable<CharT> Container, class Compare>
  struct formatter<priority_queue<T, Container, Compare>, CharT>;
}

Modèle de classe 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::référence;
    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 InputIter>
    queue(InputIter first, InputIter last);
    template<container-compatible-range<T> R>
    queue(from_range_t, R&& rg);
    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 InputIter, class Alloc>
    queue(InputIter first, InputIter last, const Alloc&);
    template<container-compatible-range<T> R, class Alloc>
    queue(from_range_t, R&& rg, 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.retour(); }
    const_reference back() const { return c.retour(); }
    void push(const value_type& x) { c.push_back(x); }
    void push(value_type&& x) { c.push_back(std::move(x)); }
    template<container-compatible-range<T> R>
    void push_range(R&& rg);
    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 InputIter>
  queue(InputIter, InputIter) -> queue</*iter-value-type*/<InputIter>>;
  template<ranges::input_range R>
  queue(from_range_t, R&&) -> queue<ranges::range_value_t<R>>;
  template<class Container, class Allocator>
  queue(Container, Allocator) -> queue<typename Container::value_type, Container>;
  template<class InputIter, class Allocator>
  queue(InputIter, InputIter, Allocator)
    -> queue</*iter-value-type*/<InputIter>,
             deque</*iter-value-type*/<InputIter>, Allocator>>;
  template<ranges::input_range R, class Allocator>
  queue(from_range_t, R&&, Allocator)
    -> queue<ranges::range_value_t<R>, deque<ranges::range_value_t<R>, Allocator>>;
  template<class T, class Container, class Alloc>
  struct uses_allocator<queue<T, Container>, Alloc>
    : uses_allocator<Container, Alloc>::type
  {};
}

Modèle de classe 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::référence;
    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 InputIter>
    priority_queue(InputIter first, InputIter last, const Compare& x = Compare());
    template<class InputIter>
    priority_queue(InputIter first, InputIter last, const Compare& x, const Container&);
    template<class InputIter>
    priority_queue(InputIter first, InputIter last, const Compare& x, Container&&);
    template<container-compatible-range<T> R>
    priority_queue(from_range_t, R&& rg, const Compare& x = Compare());
    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 InputIter, class Alloc>
    priority_queue(InputIter, InputIter, const Alloc&);
    template<class InputIter, class Alloc>
    priority_queue(InputIter, InputIter, const Compare&, const Alloc&);
    template<class InputIter, class Alloc>
    priority_queue(InputIter, InputIter, const Compare&, const Container&, const Alloc&);
    template<class InputIter, class Alloc>
    priority_queue(InputIter, InputIter, const Compare&, Container&&, const Alloc&);
    template<container-compatible-range<T> R, class Alloc>
    priority_queue(from_range_t, R&& rg, const Compare&, const Alloc&);
    template<container-compatible-range<T> R, class Alloc>
    priority_queue(from_range_t, R&& rg, 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<container-compatible-range<T> R>
    void push_range(R&& rg);
    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 InputIter,
           class Compare   = less</*iter-value-type*/<InputIter>>,
           class Container = vector</*iter-value-type*/<InputIter>>>
  priority_queue(InputIter, InputIter, Compare = Compare(), Container = Container())
    -> priority_queue</*iter-value-type*/<InputIter>, Container, Compare>;
  template<ranges::input_range R, class Compare = less<ranges::range_value_t<R>>>
  priority_queue(from_range_t, R&&, Compare = Compare())
    -> priority_queue<ranges::range_value_t<R>,
                      vector<ranges::range_value_t<R>>,
                      Compare>;
  template<class Compare, class Container, class Allocator>
  priority_queue(Compare, Container, Allocator)
    -> priority_queue<typename Container::value_type, Container, Compare>;
  template<class InputIter, class Allocator>
  priority_queue(InputIter, InputIter, Allocator)
    -> priority_queue</*iter-value-type*/<InputIter>,
                      vector</*iter-value-type*/<InputIter>, Allocator>,
                      less</*iter-value-type*/<InputIter>>>;
  template<class InputIter, class Compare, class Allocator>
  priority_queue(InputIter, InputIter, Compare, Allocator)
    -> priority_queue</*iter-value-type*/<InputIter>,
                      vector</*iter-value-type*/<InputIter>, Allocator>,
                      Compare>;
  template<class InputIter, class Compare, class Container, class Allocator>
  priority_queue(InputIter, InputIter, Compare, Container, Allocator)
    -> priority_queue<typename Container::value_type, Container, Compare>;
  template<ranges::input_range R, class Compare, class Allocator>
  priority_queue(from_range_t, R&&, Compare, Allocator)
    -> priority_queue<ranges::range_value_t<R>,
                      vector<ranges::range_value_t<R>, Allocator>,
                      Compare>;
  template<ranges::input_range R, class Allocator>
  priority_queue(from_range_t, R&&, Allocator)
    -> priority_queue<ranges::range_value_t<R>,
                      vector<ranges::range_value_t<R>, Allocator>>;
  // aucune égalité n'est fournie
  template<class T, class Container, class Compare, class Alloc>
  struct uses_allocator<priority_queue<T, Container, Compare>, Alloc>
    : uses_allocator<Container, Alloc>::type
  {};
}