Namespaces
Variants

Utility library

From cppreference.net
C++
Utilities library

C++ inclut une variété de bibliothèques utilitaires qui fournissent des fonctionnalités allant du comptage de bits à l'application partielle de fonctions . Ces bibliothèques peuvent être globalement divisées en deux groupes :

  • bibliothèques de support linguistique, et
  • bibliothèques à usage général.

Table des matières

Support des langues

Les bibliothèques de support du langage fournissent des classes et des fonctions qui interagissent étroitement avec les fonctionnalités du langage et prennent en charge les idiomes courants du langage.

Propriétés d'implémentation (depuis C++20)

L'en-tête <version> fournit des informations dépendantes de l'implémentation concernant la bibliothèque standard C++ (telles que le numéro de version et la date de publication). Il définit également les macros de test de fonctionnalités de la bibliothèque .

Support des types

Types de base (par ex. std::size_t , std::nullptr_t ), RTTI (par ex. std::type_info )

Utilitaires de programme

Arrêt (par ex. std::abort , std::atexit ), environnement (par ex. std::system ), signaux (par ex. std::raise ).

Gestion dynamique de la mémoire

Pointeurs intelligents (par ex. std::shared_ptr ), allocateurs (par ex. std::allocator ou std::pmr::memory_resource ), gestion de mémoire de style C (par ex. std::malloc ).

Gestion des erreurs

Exceptions (par ex. std::exception , std::terminate ), assertions (par ex. assert ).

Fonctions variadiques

Prise en charge des fonctions acceptant un nombre arbitraire de paramètres (via par exemple va_start , va_arg , va_end ).

Listes d'initialisation (depuis C++11)

Défini dans l'en-tête <initializer_list>
(C++11)
référence un tableau temporaire créé dans l'initialisation de liste
(modèle de classe)

Capture d'informations du code source (depuis C++20)

Défini dans l'en-tête <source_location>
(C++20)
une classe représentant des informations sur le code source, telles que les noms de fichiers, les numéros de ligne et les noms de fonctions
(classe)

Comparaison à trois voies (depuis C++20)

Défini dans l'en-tête <compare>
(C++20)
spécifie que l'opérateur <=> produit un résultat cohérent sur les types donnés
(concept)
(C++20)
le type de résultat de la comparaison à trois voies qui prend en charge les 6 opérateurs, n'est pas substituable et autorise les valeurs incomparables
(classe)
(C++20)
le type de résultat de la comparaison à trois voies qui prend en charge les 6 opérateurs et n'est pas substituable
(classe)
(C++20)
le type de résultat de la comparaison à trois voies qui prend en charge les 6 opérateurs et est substituable
(classe)
(C++20)
fonctions de comparaison nommées
(fonction)
(C++20)
objet fonction contraint implémentant x <=> y
(classe)
(C++20)
obtient le type de résultat de l'opérateur de comparaison à trois voies <=> sur les types donnés
(modèle de classe)
(C++20)
la catégorie de comparaison la plus forte vers laquelle tous les types donnés peuvent être convertis
(modèle de classe)
(C++20)
effectue une comparaison à trois voies et produit un résultat de type std::strong_ordering
(objet point de personnalisation)
(C++20)
effectue une comparaison à trois voies et produit un résultat de type std::weak_ordering
(objet point de personnalisation)
(C++20)
effectue une comparaison à trois voies et produit un résultat de type std::partial_ordering
(objet point de personnalisation)
(C++20)
effectue une comparaison à trois voies et produit un résultat de type std::strong_ordering , même si operator <=> n'est pas disponible
(objet point de personnalisation)
(C++20)
effectue une comparaison à trois voies et produit un résultat de type std::weak_ordering , même si operator <=> n'est pas disponible
(objet point de personnalisation)
(C++20)
effectue une comparaison à trois voies et produit un résultat de type std::partial_ordering , même si operator <=> n'est pas disponible
(objet point de personnalisation)

Support des coroutines (depuis C++20)

Types pour la prise en charge des coroutines (par exemple std::coroutine_traits , std::coroutine_handle ).

Support des contrats (depuis C++26)

Types pour contract support (par ex. std::contracts::contract_violation ).

Utilitaires à usage général

Échange

Défini dans l'en-tête <utility>
é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)
Défini dans l'en-tête <concepts>
(C++20)
échange les valeurs de deux objets
(objet de point de personnalisation)

Opérations sur les types (depuis C++11)

Défini dans l'en-tête <utility>
(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 template spécifié
(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
(modèle de fonction)
(C++17)
obtient une référence const vers son argument
(modèle de fonction)
(C++11)
obtient une référence vers un objet du type template pour utilisation dans un contexte non évalué
(modèle de fonction)
(C++23)
convertit une énumération vers son type sous-jacent
(modèle de fonction)

Fonctions de comparaison d'entiers (depuis C++20)

Défini dans l'en-tête <utility>
(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)

Opérateurs relationnels (jusqu'à C++20)

Défini dans l'en-tête <utility>
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)

Étiquettes de construction (depuis C++11)

Défini dans l'en-tête <utility>
(C++11)
étiquette de construction par morceaux
(étiquette)
(C++17)
étiquette de construction en place
(étiquette)
(C++26)
étiquette de construction de valeur
(étiquette)

Paires et tuples

Défini dans l'en-tête <utility>
implémente un tuple binaire, c'est-à-dire une paire de valeurs
(modèle de classe)
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)
(C++17)
appelle une fonction avec un tuple d'arguments
(modèle de fonction)
(C++17)
construit un objet avec un tuple d'arguments
(modèle de fonction)
Protocole tuple (depuis C++11)
Défini dans l'en-tête <tuple>
Défini dans l'en-tête <utility>
Défini dans l'en-tête <array>
Défini dans l'en-tête <ranges>
Défini dans l'en-tête <complex>
(C++11)
obtient le nombre d'éléments d'un type de type tuple
(modèle de classe)
(C++11)
obtient les types d'éléments d'un type de type tuple
(modèle de classe)

Types sommes et wrappers à effacement de type (depuis C++17)

Défini dans l'en-tête <optional>
(C++17)
un wrapper qui peut contenir ou non un objet
(modèle de classe)
Défini dans l'en-tête <expected>
(C++23)
un wrapper qui contient soit une valeur attendue soit une valeur d'erreur
(modèle de classe)
Défini dans l'en-tête <variant>
(C++17)
une union discriminée type-safe
(modèle de classe)
Défini dans l'en-tête <any>
(C++17)
objets qui contiennent des instances de tout type CopyConstructible
(classe)

Bitset

Défini dans l'en-tête <bitset>
implémente un tableau de bits de longueur constante
(modèle de classe)

Manipulation de bits (depuis C++20)

L'en-tête <bit> fournit plusieurs modèles de fonctions pour accéder, manipuler et traiter des bits individuels et des séquences de bits. L'ordre des octets ( endianness ) des types scalaires peut être inspecté via la fonctionnalité std:: endian .

Objets fonction (depuis C++11)

Application partielle de fonction (par exemple std::bind ) et utilitaires associés : utilitaires pour la liaison tels que std::ref et std::placeholders , enveloppes de fonctions polymorphes : std::function , foncteurs prédéfinis (par exemple std::plus , std::equal_to ), convertisseurs de pointeur-vers-membre vers fonction std::mem_fn .

Support de hachage (depuis C++11)

Défini dans l'en-tête <functional>
(C++11)
objet fonction de hachage
(modèle de classe)

Voir aussi

Documentation C pour Bibliothèque d'utilitaires