Namespaces
Variants

Standard library header <utility>

From cppreference.net
C++
Standard library headers

Cet en-tête fait partie de la bibliothèque d'utilitaires généraux .

Table des matières

Inclusions

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

Espaces de noms

rel_ops Fournit des opérateurs de comparaison automatiques
Défini dans l'espace de noms std::rel_ops
(obsolète en C++20)
génère automatiquement les opérateurs de comparaison basés sur operator == et operator < définis par l'utilisateur
(modèle de fonction)

Fonctions

échange les valeurs de deux objets
(modèle de fonction)
(C++14)
remplace l'argument par une nouvelle valeur et retourne sa valeur précédente
(modèle de fonction)
(C++11)
transmet un argument de fonction et utilise l'argument de type template pour préserver sa catégorie de valeur
(modèle de fonction)
(C++23)
transmet un argument de fonction comme s'il était converti vers la catégorie de valeur et la constance de l'expression du type spécifié en argument du modèle
(modèle de fonction)
(C++11)
convertit l'argument en une xvalue
(modèle de fonction)
(C++11)
convertit l'argument en une xvalue si le constructeur de déplacement ne lève pas d'exception
(fonction template)
(C++17)
obtient une référence const vers son argument
(modèle de fonction)
(C++11)
obtient une référence à un objet du type template pour utilisation dans un contexte non évalué
(modèle de fonction)
(C++23)
convertit une énumération en son type sous-jacent
(modèle de fonction)
(C++20)
compare deux valeurs entières, en garantissant que les nombres signés négatifs sont inférieurs aux nombres non signés
(modèle de fonction)
(C++20)
vérifie si une valeur entière est dans la plage d'un type entier donné
(modèle de fonction)
(C++23)
marque un point d'exécution inaccessible
(fonction)
crée un objet pair dont le type est déterminé par les types des arguments
(modèle de fonction)
(supprimé en C++20) (supprimé en C++20) (supprimé en C++20) (supprimé en C++20) (supprimé en C++20) (C++20)
compare lexicographiquement les valeurs dans la pair
(modèle de fonction)
(C++11)
spécialise l'algorithme std::swap
(modèle de fonction)
(C++11)
accède à un élément d'une pair
(modèle de fonction)

Classes

implémente un tuple binaire, c'est-à-dire une paire de valeurs
(modèle de classe)
(C++11)
obtient le nombre d'éléments d'un type de type tuple
(modèle de classe)
(C++11)
obtient les types des éléments d'un type de type tuple
(modèle de classe)
(C++11)
obtient la taille d'une pair
(spécialisation de modèle de classe)
(C++11)
obtient le type des éléments de pair
(spécialisation de modèle de classe)
(C++14)
implémente une séquence d'entiers à la compilation
(modèle de classe)
Déclarations anticipées
Défini dans l'en-tête <tuple>
(C++11)
implémente un conteneur de taille fixe, qui contient des éléments de types potentiellement différents
(modèle de classe)
Défini dans l'en-tête <variant>
(C++17)
type de substitution à utiliser comme première alternative dans un variant de types non constructibles par défaut
(classe)

Constantes

(C++11)
espace réservé pour ignorer un élément lors du déballage d'un tuple en utilisant tie
(constante)

Étiquettes

(C++11)
étiquette de construction par morceaux
(balise)
(C++17)
étiquette de construction en place
(étiquette)
(C++26)
étiquette de construction de valeur
(étiquette)

Synopsis 

#include <compare>
#include <initializer_list>
namespace std {
  // échanger
  template<class T>
    constexpr void swap(T& a, T& b) noexcept(/* voir description */);
  template<class T, size_t N>
    constexpr void swap(T (&a)[N], T (&b)[N]) noexcept(is_nothrow_swappable_v<T>);
  // échange
  template<class T, class U = T>
    constexpr T exchange(T& obj, U&& new_val);
  // forward/move
  template<class T>
    constexpr T&& forward(remove_reference_t<T>& t) noexcept;
  template<class T>
    constexpr T&& forward(remove_reference_t<T>&& t) noexcept;
  template<class T, class U>
    constexpr /* voir description */ forward_like(U&& x) noexcept;
  template<class T>
    constexpr remove_reference_t<T>&& move(T&&) noexcept;
  template<class T>
    constexpr conditional_t<
        !is_nothrow_move_constructible_v<T> && is_copy_constructible_v<T>, const T&, T&&>
      move_if_noexcept(T& x) noexcept;
  // as_const
  template<class T>
    constexpr add_const_t<T>& as_const(T& t) noexcept;
  template<class T>
    void as_const(const T&&) = delete;
  // declval
  template<class T>
    add_rvalue_reference_t<T> declval() noexcept;   // en tant qu'opérande non évalué
  // fonctions de comparaison d'entiers
  template<class T, class U>
    constexpr bool cmp_equal(T t, U u) noexcept;
  template<class T, class U>
    constexpr bool cmp_not_equal(T t, U u) noexcept;
  template<class T, class U>
    constexpr bool cmp_less(T t, U u) noexcept;
  template<class T, class U>
    constexpr bool cmp_greater(T t, U u) noexcept;
  template<class T, class U>
    constexpr bool cmp_less_equal(T t, U u) noexcept;
  template<class T, class U>
    constexpr bool cmp_greater_equal(T t, U u) noexcept;
  template<class R, class T>
    constexpr bool in_range(T t) noexcept;
  // to_underlying
  template<class T>
    constexpr underlying_type_t<T> to_underlying(T value) noexcept;
  // inaccessible
  [[noreturn]] void unreachable();
  // séquences d'entiers à la compilation
  template<class T, T...>
    struct integer_sequence;
  template<size_t... I>
    using index_sequence = integer_sequence<size_t, I...>;
  template<class T, T N>
    using make_integer_sequence = integer_sequence<T, /* voir description */>;
  template<size_t N>
    using make_index_sequence = make_integer_sequence<size_t, N>;
  template<class... T>
    using index_sequence_for = make_index_sequence<sizeof...(T)>;
  // modèle de classe pair
  template<class T1, class T2>
    struct pair;
  // algorithmes spécialisés pour pair
  template<class T1, class T2>
    constexpr bool operator==(const pair<T1, T2>&, const pair<T1, T2>&);
  template<class T1, class T2>
    constexpr common_comparison_category_t</*synth-three-way-result*/<T1>,
                                           /*synth-three-way-result*/<T2>>
      operator<=>(const pair<T1, T2>&, const pair<T1, T2>&);
  template<class T1, class T2>
    constexpr void swap(pair<T1, T2>& x, pair<T1, T2>& y) noexcept(noexcept(x.swap(y)));
  template<class T1, class T2>
    constexpr /* voir description */ make_pair(T1&&, T2&&);
  // accès de type tuple à pair
  template<class T> struct tuple_size;
  template<size_t I, class T> struct tuple_element;
  template<class T1, class T2> struct tuple_size<pair<T1, T2>>;
  template<size_t I, class T1, class T2> struct tuple_element<I, pair<T1, T2>>;
  template<size_t I, class T1, class T2>
    constexpr tuple_element_t<I, pair<T1, T2>>& get(pair<T1, T2>&) noexcept;
  template<size_t I, class T1, class T2>
    constexpr tuple_element_t<I, pair<T1, T2>>&& get(pair<T1, T2>&&) noexcept;
  template<size_t I, class T1, class T2>
    constexpr const tuple_element_t<I, pair<T1, T2>>& get(const pair<T1, T2>&) noexcept;
  template<size_t I, class T1, class T2>
    constexpr const tuple_element_t<I, pair<T1, T2>>&& get(const pair<T1, T2>&&) noexcept;
  template<class T1, class T2>
    constexpr T1& get(pair<T1, T2>& p) noexcept;
  template<class T1, class T2>
    constexpr const T1& get(const pair<T1, T2>& p) noexcept;
  template<class T1, class T2>
    constexpr T1&& get(pair<T1, T2>&& p) noexcept;
  template<class T1, class T2>
    constexpr const T1&& get(const pair<T1, T2>&& p) noexcept;
  template<class T2, class T1>
    constexpr T2& get(pair<T1, T2>& p) noexcept;
  template<class T2, class T1>
    constexpr const T2& get(const pair<T1, T2>& p) noexcept;
  template<class T2, class T1>
    constexpr T2&& get(pair<T1, T2>&& p) noexcept;
  template<class T2, class T1>
    constexpr const T2&& get(const pair<T1, T2>&& p) noexcept;
  // construction par morceaux de pair
  struct piecewise_construct_t {
    explicit piecewise_construct_t() = default;
  };
  inline constexpr piecewise_construct_t piecewise_construct{};
  template<class... Types> class tuple;         // défini dans <tuple>
  // construction en place
  struct in_place_t {
    explicit in_place_t() = default;
  };
  inline constexpr in_place_t in_place{};
  template<class T>
    struct in_place_type_t {
      explicit in_place_type_t() = default;
    };
  template<class T> inline constexpr in_place_type_t<T> in_place_type{};
  template<size_t I>
    struct in_place_index_t {
      explicit in_place_index_t() = default;
    };
  template<size_t I> inline constexpr in_place_index_t<I> in_place_index{};
  // argument de non-type tag
  template<auto V>
    struct nontype_t {
      explicit nontype_t() = default;
    };
  template<auto V> inline constexpr nontype_t<V> nontype{};
}
// obsolète
namespace std::rel_ops {
  template<class T> bool operator!=(const T&, const T&);
  template<class T> bool operator> (const T&, const T&);
  template<class T> bool operator<=(const T&, const T&);
  template<class T> bool operator>=(const T&, const T&);
}

Modèle de classe std::integer_sequence 

namespace std {
  template<class T, T... I> struct integer_sequence {
    using value_type = T;
    static constexpr size_t size() noexcept { return sizeof...(I); }
  };
}

Modèle de classe std::pair 

namespace std {
  template<class T1, class T2>
  struct pair {
    using first_type  = T1;
    using second_type = T2;
    T1 first;
    T2 second;
    pair(const pair&) = default;
    pair(pair&&) = default;
    constexpr explicit(/* voir description */) pair();
    constexpr explicit(/* voir description */) pair(const T1& x, const T2& y);
    template<class U1 = T1, class U2 = T2>
      constexpr explicit(/* voir description */) pair(U1&& x, U2&& y);
    template<class U1, class U2>
      constexpr explicit(/* voir description */) pair(const pair<U1, U2>& p);
    template<class U1, class U2>
      constexpr explicit(/* voir description */) pair(pair<U1, U2>&& p);
    template<class... Args1, class... Args2>
      constexpr pair(piecewise_construct_t,
                     tuple<Args1...> first_args, tuple<Args2...> second_args);
    constexpr pair& operator=(const pair& p);
    template<class U1, class U2>
      constexpr pair& operator=(const pair<U1, U2>& p);
    constexpr pair& operator=(pair&& p) noexcept(/* voir description */);
    template<class U1, class U2>
      constexpr pair& operator=(pair<U1, U2>&& p);
    constexpr void swap(pair& p) noexcept(/* voir description */);
  };
  template<class T1, class T2>
    pair(T1, T2) -> pair<T1, T2>;
}

Voir aussi

(C++11)
std::tuple modèle de classe