Namespaces
Variants

Standard library header <hive> (C++26)

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)
Support de l'opérateur de comparaison à trois voies
(C++11)
std::initializer_list modèle de classe

Classes

(C++26)
informations de disposition sur les limites de capacité des blocs dans std::hive
(classe)
(C++26)
collection qui réutilise la mémoire des éléments effacés
(modèle de classe)

Fonctions

(C++26)
spécialise l'algorithme std::swap
(modèle de fonction)
(C++26)
efface tous les éléments satisfaisant des critères spécifiques
(modèle de fonction)

Synopsis 

#include <compare>
#include <initializer_list>
namespace std {
  struct hive_limits
  {
    size_t min;
    size_t max;
    constexpr hive_limits(size_t minimum, size_t maximum) noexcept
    : min(minimum), max(maximum) {}
  };
  // modèle de classe hive
  template<class T, class Allocator = allocator<T>>
  class hive;
  // échange
  template<class T, class Allocator>
  void swap(hive<T, Allocator>& x, hive<T, Allocator>& y) noexcept(noexcept(x.swap(y)));
  template<class T, class Allocator, class U = T>
  typename hive<T, Allocator>::size_type erase(hive<T, Allocator>& c, const U& value);
  template<class T, class Allocator, class Predicate>
  typename hive<T, Allocator>::size_type erase_if(hive<T, Allocator>& c, Predicate pred);
  namespace pmr {
    template<class T>
    using hive = std::hive<T, polymorphic_allocator<T>>;
  }
}

Modèle de classe std :: hive 

namespace std {
  template<class T, class Allocator>
  class hive
  {
  public:
    // types:
    using value_type             = T;
    using allocator_type         = Allocator;
    using pointer                = allocator_traits<Allocator>::pointeur;
    using const_pointer          = allocator_traits<Allocator>::const_pointer;
    using reference              = value_type&;
    using const_reference        = const value_type&;
    using size_type              = /* défini par l'implémentation */;
    using difference_type        = /* défini par l'implémentation */;
    using iterator               = /* défini par l'implémentation */;
    using const_iterator         = /* défini par l'implémentation */;
    using reverse_iterator       = std::reverse_iterator<iterator>;
    using const_reverse_iterator = std::reverse_iterator<const_iterator>;
    // construction/copie/destruction
    constexpr hive() noexcept(noexcept(Allocator())) : hive(Allocator()) {}
    constexpr explicit hive(const Allocator&) noexcept;
    constexpr explicit hive(hive_limits block_limits) : hive(block_limits, Allocator()) {}
    constexpr hive(hive_limits block_limits, const Allocator&);
    explicit hive(size_type n, const Allocator& = Allocator());
    hive(size_type n, const T& value, const Allocator& = Allocator());
    hive(size_type n, const T& value, hive_limits block_limits, 
         const Allocator& = Allocator());
    template<class InputIter>
    hive(InputIter first, InputIter last, const Allocator& = Allocator());
    template<class InputIter>
    hive(InputIter first, InputIter last, hive_limits block_limits, 
         const Allocator& = Allocator());
    template<container-compatible-range<T> R>
    hive(from_range_t, R&& rg, const Allocator& = Allocator());
    template<container-compatible-range<T> R>
    hive(from_range_t, R&& rg, hive_limits block_limits, const Allocator& = Allocator());
    hive(const hive& other);
    hive(hive&& other) noexcept;
    hive(const hive& other, const type_identity_t<Allocator>& alloc);
    hive(hive&& other, const type_identity_t<Allocator>& alloc);
    hive(initializer_list<T> il, const Allocator& = Allocator());
    hive(initializer_list<T> il, hive_limits block_limits, const Allocator& = Allocator());
    ~hive();
    hive& operator=(const hive& other);
    hive& operator=(hive&& other) 
      noexcept(allocator_traits<Allocator>::propagate_on_container_move_assignment::value
            || allocator_traits<Allocator>::is_always_equal::value);
    hive& operator=(initializer_list<T>);
    template<class InputIter>
    void assign(InputIter first, InputIter last);
    template<container-compatible-range<T> R>
    void assign_range(R&& rg);
    void assign(size_type n, const T& value);
    void assign(initializer_list<T> il);
    allocator_type get_allocator() const noexcept;
    // itérateurs
    iterator begin() noexcept;
    const_iterator begin() const noexcept;
    iterator end() noexcept;
    const_iterator end() const noexcept;
    reverse_iterator rbegin() noexcept;
    const_reverse_iterator rbegin() const noexcept;
    reverse_iterator rend() noexcept;
    const_reverse_iterator rend() const noexcept;
    const_iterator cbegin() const noexcept;
    const_iterator cend() const noexcept;
    const_reverse_iterator crbegin() const noexcept;
    const_reverse_iterator crend() const noexcept;
    // taille/capacité
    bool empty() const noexcept;
    size_type size() const noexcept;
    size_type max_size() const noexcept;
    size_type capacity() const noexcept;
    void reserve(size_type n);
    void shrink_to_fit();
    void trim_capacity() noexcept;
    void trim_capacity(size_type n) noexcept;
    constexpr hive_limits block_capacity_limits() const noexcept;
    static constexpr hive_limits block_capacity_default_limits() noexcept;
    static constexpr hive_limits block_capacity_hard_limits() noexcept;
    void reshape(hive_limits block_limits);
    // modificateurs
    template<class... Args>
    iterator emplace(Args&&... args);
    template<class... Args>
    iterator emplace_hint(const_iterator hint, Args&&... args);
    iterator insert(const T& x);
    iterator insert(T&& x);
    iterator insert(const_iterator hint, const T& x);
    iterator insert(const_iterator hint, T&& x);
    void insert(initializer_list<T> il);
    template<container-compatible-range<T> R>
    void insert_range(R&& rg);
    template<class InputIter>
    void insert(InputIter first, InputIter last);
    void insert(size_type n, const T& x);
    iterator erase(const_iterator position);
    iterator erase(const_iterator first, const_iterator last);
    void swap(hive&)
      noexcept(allocator_traits<Allocator>::propagate_on_container_swap::value
            || allocator_traits<Allocator>::is_always_equal::value);
    void clear() noexcept;
    // opérations hive
    void splice(hive& other);
    void splice(hive&& other);
    template<class BinaryPredicate = equal_to<T>>
    size_type unique(BinaryPredicate binary_pred = BinaryPredicate());
    template<class Compare = less<T>>
    void sort(Compare comp = Compare());
    iterator get_iterator(const_pointer p) noexcept;
    const_iterator get_iterator(const_pointer p) const noexcept;
  private:
    // exposition uniquement
    hive_limits current_limits_ = /* défini par l'implémentation */ 
  };
  template<class InputIter, class Allocator = allocator</*iter-value-type*/<InputIter>>
  hive(InputIter, InputIter, Allocator = Allocator())
    -> hive</*iter-value-type*/<InputIter>, Allocator>;
  template<class InputIter, class Allocator = allocator</*iter-value-type*/<InputIter>>
  hive(InputIter, InputIter, hive_limits, Allocator = Allocator())
    -> hive</*iter-value-type*/<InputIter>, Allocator>;
  template<ranges::input_range R, class Allocator = allocator<ranges::range_value_t<R>>>
  hive(from_range_t, R&&, Allocator = Allocator())
    -> hive<ranges::range_value_t<R>, Allocator>;
  template<ranges::input_range R, class Allocator = allocator<ranges::range_value_t<R>>>
  hive(from_range_t, R&&, hive_limits, Allocator = Allocator())
    -> hive<ranges::range_value_t<R>, Allocator>;
}