Standard library header <memory>

From fr.cppreference.net

Cet en-tête fait partie de la bibliothèque de gestion de la mémoire dynamique .

Sommaire 1 Inclusions 2 Classes 2.1 Traits de pointeur 2.2 Support du ramasse-miettes 2.3 Allocateurs 2.4 Stockage non initialisé 2.5 Pointeurs intelligents 2.6 Adaptateurs de pointeurs intelligents 2.7 Types pour la conception de classes composites 2.8 Classes auxiliaires 2.9 Déclarations anticipées 3 Étiquettes 4 Fonctions / Entités de type fonction 4.1 Construction avec allocateur 4.2 Divers 4.3 Gestion explicite de la durée de vie 4.4 Support du ramasse-miettes 4.5 Spécialisés <memory> algorithmes 4.6 Opérations non membres des pointeurs intelligents 4.7 Création d'adaptateurs de pointeurs intelligents 5 Synopsis 5.1 Modèle de classe std::pointer_traits 5.2 Classe std::allocator_arg_t 5.3 Modèle de classe std::allocator_traits 5.4 Modèle de classe std::allocator 5.5 Modèle de classe std::default_delete 5.6 Modèle de classe std::unique_ptr 5.7 Classe std::bad_weak_ptr 5.8 Modèle de classe std::shared_ptr 5.9 Modèle de classe std::weak_ptr 5.10 Modèle de classe std::owner_less 5.11 Classe std::owner_hash 5.12 Classe std::owner_equal 5.13 Modèle de classe std::enable_shared_from_this 5.14 Modèle de classe std::atomic spécialisation pour std::shared_ptr 5.15 Modèle de classe std::atomic spécialisation pour std::weak_ptr 5.16 Modèle de classe std::out_ptr_t 5.17 Modèle de classe std::inout_ptr_t 5.18 Modèle de classe std::indirect 5.19 Modèle de classe std::polymorphic Inclusions
<compare> (C++20)	Opérateur de comparaison à trois voies support
Classes
Caractéristiques des pointeurs
pointer_traits (C++11)	fournit des informations sur les types de type pointeur (modèle de classe)
Prise en charge du ramasse-miettes
pointer_safety (C++11) (removed in C++23)	énumère les modèles de sécurité des pointeurs (enum)
Allocateurs
allocator	l'allocateur par défaut (modèle de classe)
allocator_traits (C++11)	fournit des informations sur les types d'allocateur (modèle de classe)
allocation_result (C++23)	enregistre l'adresse et la taille réelle de la mémoire allouée par `allocate_at_least` (modèle de classe)
uses_allocator (C++11)	vérifie si le type spécifié prend en charge la construction avec allocateur (modèle de classe)
Stockage non initialisé
raw_storage_iterator (obsolète en C++17) (supprimé en C++20)	un itérateur qui permet aux algorithmes standard de stocker des résultats dans une mémoire non initialisée (modèle de classe)
Pointeurs intelligents
unique_ptr (C++11)	pointeur intelligent avec sémantique de propriété exclusive d'objet (modèle de classe)
shared_ptr (C++11)	pointeur intelligent avec sémantique de propriété partagée d'objet (modèle de classe)
weak_ptr (C++11)	référence faible vers un objet géré par std::shared_ptr (modèle de classe)
auto_ptr (obsolète en C++11) (supprimé en C++17)	pointeur intelligent avec sémantique de propriété stricte des objets (modèle de classe)
Adaptateurs de pointeurs intelligents
out_ptr_t (C++23)	interagit avec les définisseurs de pointeurs étrangers et réinitialise un pointeur intelligent lors de la destruction (modèle de classe)
inout_ptr_t (C++23)	interagit avec les définisseurs de pointeurs étrangers, obtient la valeur initiale du pointeur depuis un pointeur intelligent et le réinitialise lors de la destruction (modèle de classe)
Types pour la conception de classes composites
indirect (C++26)	un wrapper contenant un objet alloué dynamiquement avec une sémantique de type valeur (modèle de classe)
polymorphic (C++26)	un wrapper polymorphique contenant un objet alloué dynamiquement avec une sémantique de valeur (modèle de classe)
Classes auxiliaires
std::atomic <std::shared_ptr> (C++20)	pointeur partagé atomique (spécialisation de modèle de classe)
std::atomic <std::weak_ptr> (C++20)	pointeur faible atomique (spécialisation de modèle de classe)
owner_less (C++11)	fournit un ordonnancement basé sur le propriétaire de type mixte pour les pointeurs partagés et faibles (modèle de classe)
owner_hash (C++26)	fournit un hachage basé sur le propriétaire pour les pointeurs partagés et faibles (classe)
owner_equal (C++26)	fournit des comparaisons d'égalité basées sur le propriétaire de types mixtes pour les pointeurs partagés et faibles (classe)
enable_shared_from_this (C++11)	permet à un objet de créer un `shared_ptr` se référant à lui-même (modèle de classe)
bad_weak_ptr (C++11)	exception levée lors de l'accès à un `weak_ptr` qui fait référence à un objet déjà détruit (classe)
default_delete (C++11)	suppresseur par défaut pour unique_ptr (modèle de classe)
std::hash <std::unique_ptr> (C++11)	Prise en charge du hachage pour `std::unique_ptr` (spécialisation de modèle de classe)
std::hash <std::shared_ptr> (C++11)	Support de hachage pour `std::shared_ptr` (spécialisation de modèle de classe)
std::hash <std::indirect> (C++26)	Support de hachage pour `std::indirect` (spécialisation de modèle de classe)
Déclarations anticipées
Défini dans l'en-tête `<functional>`
hash (C++11)	objet fonction de hachage (modèle de classe)
Défini dans l'en-tête `<atomic>`
atomic (C++11)	modèle de classe atomic et spécialisations pour bool, types entiers, types à virgule flottante, (depuis C++20) et types pointeurs (modèle de classe)
Étiquettes
allocator_arg allocator_arg_t (C++11)	une étiquette utilisée pour sélectionner les constructeurs compatibles avec les allocateurs (étiquette)
Fonctions / Entités de type fonction
Construction avec allocateur
uses_allocator_construction_args (C++20)	prépare la liste d'arguments correspondant au type de construction uses-allocator requis par le type donné (modèle de fonction)
make_obj_using_allocator (C++20)	crée un objet du type donné au moyen d'une construction uses-allocator (fonction template)
uninitialized_construct_using_allocator (C++20)	crée un objet du type donné à l'emplacement mémoire spécifié au moyen d'une construction avec allocateur (modèle de fonction)
Divers
to_address (C++20)	obtient un pointeur brut à partir d'un type similaire à un pointeur (modèle de fonction)
addressof (C++11)	obtient l'adresse réelle d'un objet, même si l'opérateur `&` est surchargé (fonction template)
align (C++11)	aligne un pointeur dans un tampon (fonction)
assume_aligned (C++20)	informe le compilateur qu'un pointeur est aligné (modèle de fonction)
is_sufficiently_aligned (C++26)	vérifie si le pointeur pointe vers un objet dont l'alignement a au moins la valeur donnée (modèle de fonction)
Gestion explicite de la durée de vie
start_lifetime_as start_lifetime_as_array (C++23)	crée implicitement des objets dans un stockage donné en réutilisant la représentation d'objet (modèle de fonction)
Prise en charge du ramasse-miettes
declare_reachable (C++11) (supprimé en C++23)	déclare qu'un objet ne peut pas être recyclé (fonction)
undeclare_reachable (C++11) (supprimé en C++23)	déclare qu'un objet peut être recyclé (modèle de fonction)
declare_no_pointers (C++11) (supprimé en C++23)	déclare qu'une zone mémoire ne contient pas de pointeurs traçables (fonction)
undeclare_no_pointers (C++11) (supprimé en C++23)	annule l'effet de std::declare_no_pointers (fonction)
get_pointer_safety (C++11) (supprimé en C++23)	renvoie le modèle actuel de sécurité des pointeurs (fonction)
Spécialisés `<memory>` algorithmes
uninitialized_copy	copie une plage d'objets dans une zone mémoire non initialisée (modèle de fonction & objet fonction d'algorithme)
ranges::uninitialized_copy (C++20)
uninitialized_copy_n (C++11)	copie un nombre d'objets dans une zone mémoire non initialisée (modèle de fonction & objet fonction d'algorithme)
ranges::uninitialized_copy_n (C++20)
uninitialized_fill	copie un objet dans une zone mémoire non initialisée, définie par une plage (modèle de fonction & objet fonction d'algorithme)
ranges::uninitialized_fill (C++20)
uninitialized_fill_n	copie un objet dans une zone mémoire non initialisée, définie par un début et un compte (modèle de fonction & objet fonction d'algorithme)
ranges::uninitialized_fill_n (C++20)
uninitialized_move (C++17)	déplace une plage d'objets dans une zone mémoire non initialisée (modèle de fonction & objet fonction d'algorithme)
ranges::uninitialized_move (C++20)
uninitialized_move_n (C++17)	déplace un nombre d'objets dans une zone mémoire non initialisée (modèle de fonction & objet fonction d'algorithme)
ranges::uninitialized_move_n (C++20)
uninitialized_default_construct (C++17)	construit des objets par initialisation par défaut dans une zone mémoire non initialisée, définie par une plage (modèle de fonction & objet fonction d'algorithme)
ranges::uninitialized_default_construct (C++20)
uninitialized_default_construct_n (C++17)	construit des objets par initialisation par défaut dans une zone mémoire non initialisée, définie par un début et un compte (modèle de fonction & objet fonction d'algorithme)
ranges::uninitialized_default_construct_n (C++20)
uninitialized_value_construct (C++17)	construit des objets par initialisation par valeur dans une zone mémoire non initialisée, définie par une plage (modèle de fonction & objet fonction d'algorithme)
ranges::uninitialized_value_construct (C++20)
uninitialized_value_construct_n (C++17)	construit des objets par initialisation par valeur dans une zone mémoire non initialisée, définie par un début et un compte (modèle de fonction & objet fonction d'algorithme)
ranges::uninitialized_value_construct_n (C++20)
construct_at (C++20)	crée un objet à une adresse donnée (modèle de fonction & objet fonction d'algorithme)
ranges::construct_at (C++20)
destroy_at (C++17)	détruit un objet à une adresse donnée (modèle de fonction & objet fonction d'algorithme)
ranges::destroy_at (C++20)
destroy (C++17)	détruit une plage d'objets (modèle de fonction & objet fonction d'algorithme)
ranges::destroy (C++20)
destroy_n (C++17)	détruit un nombre d'objets dans une plage (modèle de fonction & objet fonction d'algorithme)
ranges::destroy_n (C++20)
get_temporary_buffer (déprécié en C++17)(supprimé en C++20)	obtient un stockage non initialisé (modèle de fonction)
return_temporary_buffer (déprécié en C++17)(supprimé en C++20)	libère un stockage non initialisé (modèle de fonction)
Opérations non membres sur les pointeurs intelligents
make_unique make_unique_for_overwrite (C++14) (C++20)	crée un pointeur unique qui gère un nouvel objet (modèle de fonction)
operator== operator!= operator< operator<= operator> operator>= operator<=> (supprimé en C++20) (C++20)	compare avec un autre `unique_ptr` ou avec nullptr (modèle de fonction)
make_shared make_shared_for_overwrite (C++20)	crée un pointeur partagé qui gère un nouvel objet (modèle de fonction)
allocate_shared allocate_shared_for_overwrite (C++20)	crée un pointeur partagé qui gère un nouvel objet alloué à l'aide d'un allocateur (modèle de fonction)
static_pointer_cast dynamic_pointer_cast const_pointer_cast reinterpret_pointer_cast (C++17)	applique `static_cast` , `dynamic_cast` , `const_cast` , ou `reinterpret_cast` au pointeur stocké (modèle de fonction)
get_deleter	retourne le suppresseur du type spécifié, s'il est possédé (modèle de fonction)
operator== operator!= operator< operator<= operator> operator>= operator<=> (supprimé en C++20) (supprimé en C++20) (supprimé en C++20) (supprimé en C++20) (supprimé en C++20) (C++20)	compare avec un autre `shared_ptr` ou avec nullptr (modèle de fonction)
operator<< (std::shared_ptr)	affiche la valeur du pointeur stocké vers un flux de sortie (modèle de fonction)
operator<< (std::unique_ptr) (C++20)	affiche la valeur du pointeur géré vers un flux de sortie (modèle de fonction)
std::swap (std::unique_ptr) (C++11)	spécialise l'algorithme std::swap (modèle de fonction)
std::swap (std::shared_ptr) (C++11)	spécialise l'algorithme std::swap (modèle de fonction)
std::swap (std::weak_ptr) (C++11)	spécialise l'algorithme std::swap (modèle de fonction)
Création d'adaptateur de pointeur intelligent
out_ptr (C++23)	crée un `out_ptr_t` avec un pointeur intelligent associé et des arguments de réinitialisation (modèle de fonction)
inout_ptr (C++23)	crée un `inout_ptr_t` avec un pointeur intelligent associé et des arguments de réinitialisation (modèle de fonction)

std::atomic_is_lock_free(std::shared_ptr)std::atomic_load(std::shared_ptr)std::atomic_load_explicit(std::shared_ptr)std::atomic_store(std::shared_ptr)std::atomic_store_explicit(std::shared_ptr)std::atomic_exchange(std::shared_ptr)std::atomic_exchange_explicit(std::shared_ptr)std::atomic_compare_exchange_weak(std::shared_ptr)std::atomic_compare_exchange_strong(std::shared_ptr)std::atomic_compare_exchange_weak_explicit(std::shared_ptr)std::atomic_compare_exchange_strong_explicit(std::shared_ptr)

(obsolète en C++20)(supprimé en C++26)

spécialise les opérations atomiques pour std::shared_ptr
(modèle de fonction)

Synopsis

#include <compare>

namespace std {
  // pointer Traits
  template<class Ptr>
  struct pointer_traits; // freestanding
  template<class T>
  struct pointer_traits<T*>; // freestanding

  // pointer conversion
  template<class T>
  constexpr T* to_address(T* p) noexcept; // freestanding
  template<class Ptr>
  constexpr auto to_address(const Ptr& p) noexcept; // freestanding

  // pointer alignment
  void* align(size_t alignment, size_t size, void*& ptr, size_t& space); // freestanding
  template<size_t N, class T>
  constexpr T* assume_aligned(T* ptr); // freestanding
  template<size_t Alignment, class T>
  bool is_sufficiently_aligned(T* ptr);

  // explicit lifetime management
  template<class T>
  T* start_lifetime_as(void* p) noexcept; // freestanding
  template<class T>
  const T* start_lifetime_as(const void* p) noexcept; // freestanding
  template<class T>
  volatile T* start_lifetime_as(volatile void* p) noexcept; // freestanding
  template<class T>
  const volatile T* start_lifetime_as(const volatile void* p) noexcept; // freestanding
  template<class T>
  T* start_lifetime_as_array(void* p, size_t n) noexcept; // freestanding
  template<class T>
  const T* start_lifetime_as_array(const void* p, size_t n) noexcept; // freestanding
  template<class T>
  volatile T* start_lifetime_as_array(volatile void* p,
                                      size_t n) noexcept; // freestanding
  template<class T>
  const volatile T* start_lifetime_as_array(const volatile void* p, // freestanding
                                            size_t n) noexcept;
  template<class T>
  T* trivially_relocate(T* first, T* last, T* result); // freestanding
  template<class T>
  constexpr T* relocate(T* first, T* last, T* result); // freestanding

  // allocator argument tag
  struct allocator_arg_t
  {
    explicit allocator_arg_t() = default;
  };                                                // freestanding
  inline constexpr allocator_arg_t allocator_arg{}; // freestanding

  // uses_allocator
  template<class T, class Alloc>
  struct uses_allocator; // freestanding

  // uses_allocator
  template<class T, class Alloc>
  constexpr bool uses_allocator_v = uses_allocator<T, Alloc>::value; // freestanding

  // uses-allocator construction
  template<class T, class Alloc, class... Args>
  constexpr auto uses_allocator_construction_args(const Alloc& alloc, // freestanding
                                                  Args&&... args) noexcept;
  template<class T, class Alloc, class Tuple1, class Tuple2>
  constexpr auto uses_allocator_construction_args(const Alloc& alloc, // freestanding
                                                  piecewise_construct_t,
                                                  Tuple1&& x,
                                                  Tuple2&& y) noexcept;
  template<class T, class Alloc>
  constexpr auto uses_allocator_construction_args(
    const Alloc& alloc) noexcept; // freestanding
  template<class T, class Alloc, class U, class V>
  constexpr auto uses_allocator_construction_args(const Alloc& alloc, // freestanding
                                                  U&& u,
                                                  V&& v) noexcept;
  template<class T, class Alloc, class U, class V>
  constexpr auto uses_allocator_construction_args(const Alloc& alloc, // freestanding
                                                  pair<U, V>& pr) noexcept;
  template<class T, class Alloc, class U, class V>
  constexpr auto uses_allocator_construction_args(const Alloc& alloc, // freestanding
                                                  const pair<U, V>& pr) noexcept;
  template<class T, class Alloc, class U, class V>
  constexpr auto uses_allocator_construction_args(const Alloc& alloc, // freestanding
                                                  pair<U, V>&& pr) noexcept;
  template<class T, class Alloc, class U, class V>
  constexpr auto uses_allocator_construction_args(const Alloc& alloc, // freestanding
                                                  const pair<U, V>&& pr) noexcept;
  template<class T, class Alloc, /*pair-like*/ P>
  constexpr auto uses_allocator_construction_args(const Alloc& alloc, // freestanding
                                                  P&& p) noexcept;
  template<class T, class Alloc, class U>
  constexpr auto uses_allocator_construction_args(const Alloc& alloc, // freestanding
                                                  U&& u) noexcept;
  template<class T, class Alloc, class... Args>
  constexpr T make_obj_using_allocator(const Alloc& alloc,
                                       Args&&... args); // freestanding
  template<class T, class Alloc, class... Args>
  constexpr T* uninitialized_construct_using_allocator(T* p, // freestanding
                                                       const Alloc& alloc,
                                                       Args&&... args);

  // allocator Traits
  template<class Alloc>
  struct allocator_traits; // freestanding

  template<class Pointer, class SizeType = size_t>
  struct allocation_result
  { // freestanding
    Pointer ptr;
    SizeType count;
  };

  // the default allocator
  template<class T>
  class allocator;
  template<class T, class U>
  constexpr bool operator==(const allocator<T>&, const allocator<U>&) noexcept;

  // addressof
  template<class T>
  constexpr T* addressof(T& r) noexcept; // freestanding
  template<class T>
  const T* addressof(const T&&) = delete; // freestanding

  // specialized algorithms
  // special memory concepts
  template<class I>
  concept nothrow-input-iterator = /* see description */; // exposition-only
  template<class I>
  concept nothrow-forward-iterator = /* see description */; // exposition-only
  template<class I>
  concept nothrow-bidirectional-iterator = /* see description */; // exposition-only
  template<class I>
  concept nothrow-random-access-iterator = /* see description */; // exposition-only
  template<class S, class I>
  concept nothrow-sentinel-for = /* see description */; // exposition-only
  template<class S, class I>
  concept nothrow-sized-sentinel-for = /* see description */; // exposition-only
  template<class R>
  concept nothrow-input-range = /* see description */; // exposition-only
  template<class R>
  concept nothrow-forward-range = /* see description */; // exposition-only
  template<class R>
  concept nothrow-bidirectional-range = /* see description */; // exposition-only
  template<class R>
  concept nothrow-random-access-range = /* see description */; // exposition-only
  template<class R>
  concept nothrow-sized-random-access-range = /* see description */; // exposition-only

  template<class NoThrowForwardIter>
  constexpr void uninitialized_default_construct(NoThrowForwardIter first, // freestanding
                                                 NoThrowForwardIter last);
  template<class ExecutionPolicy, class NoThrowForwardIter>
  void uninitialized_default_construct(ExecutionPolicy&& exec, // freestanding-deleted
                                       NoThrowForwardIter first,
                                       NoThrowForwardIter last);
  template<class NoThrowForwardIter, class Size>
  constexpr NoThrowForwardIter uninitialized_default_construct_n(NoThrowForwardIter first,
                                                                 Size n); // freestanding
  template<class ExecutionPolicy, class NoThrowForwardIter, class Size>
  NoThrowForwardIter uninitialized_default_construct_n(
    ExecutionPolicy&& exec, // freestanding-deleted
    NoThrowForwardIter first,
    Size n);

  namespace ranges {
    template<no-throw-forward-iterator I, no-throw-sentinel-for<I> S>
      requires default_initializable<iter_value_t<I>>
    constexpr I uninitialized_default_construct(I first, S last); // freestanding
    template<no-throw-forward-range R>
      requires default_initializable<range_value_t<R>>
    constexpr borrowed_iterator_t<R> uninitialized_default_construct(
      R&& r); // freestanding

    template<no-throw-forward-iterator I>
      requires default_initializable<iter_value_t<I>>
    constexpr I uninitialized_default_construct_n(I first, // freestanding
                                                  iter_difference_t<I> n);

    template<execution-policy Ep, nothrow-random-access-iterator I,
             nothrow-sized-sentinel-for <I> S>
      requires default_initializable<iter_value_t<I>>
    I uninitialized_default_construct(Ep&& exec, I first, S last); // freestanding-deleted
    template<execution-policy Ep, nothrow-sized-random-access-range R>
      requires default_initializable<range_value_t<R>>
    borrowed_iterator_t<R> uninitialized_default_construct // freestanding-deleted
      (Ep&& exec, R&& r);

    template<execution-policy Ep, nothrow-random-access-iterator I>
      requires default_initializable<iter_value_t<I>>
    I uninitialized_default_construct_n(Ep&& exec, I first, // freestanding-deleted
                                        iter_difference_t<I> n);
  }

  template<class NoThrowForwardIter>
  constexpr void uninitialized_value_construct(NoThrowForwardIter first, // freestanding
                                               NoThrowForwardIter last);
  template<class ExecutionPolicy, class NoThrowForwardIter>
  void uninitialized_value_construct(ExecutionPolicy&& exec, // freestanding-deleted
                                     NoThrowForwardIter first,
                                     NoThrowForwardIter last);
  template<class NoThrowForwardIter, class Size>
  constexpr NoThrowForwardIter uninitialized_value_construct_n(NoThrowForwardIter first,
                                                               Size n); // freestanding
  template<class ExecutionPolicy, class NoThrowForwardIter, class Size>
  NoThrowForwardIter uninitialized_value_construct_n(
    ExecutionPolicy&& exec, // freestanding-deleted
    NoThrowForwardIter first,
    Size n);

  namespace ranges {
    template<no-throw-forward-iterator I, no-throw-sentinel-for<I> S>
      requires default_initializable<iter_value_t<I>>
    constexpr I uninitialized_value_construct(I first, S last); // freestanding
    template<no-throw-forward-range R>
      requires default_initializable<range_value_t<R>>
    constexpr borrowed_iterator_t<R> uninitialized_value_construct(R&& r); // freestanding

    template<no-throw-forward-iterator I>
      requires default_initializable<iter_value_t<I>>
    constexpr I uninitialized_value_construct_n(I first, // freestanding
                                                iter_difference_t<I> n);

    template<execution-policy Ep, nothrow-random-access-iterator I,
             nothrow-sized-sentinel-for <I> S>
      requires default_initializable<iter_value_t<I>>
    I uninitialized_value_construct(Ep&& exec, I first, S last); // freestanding-deleted
    template<execution-policy Ep, nothrow-sized-random-access-range R>
      requires default_initializable<range_value_t<R>>
    borrowed_iterator_t<R> uninitialized_value_construct // freestanding-deleted
      (Ep&& exec, R&& r);

    template<execution-policy Ep, nothrow-random-access-iterator I>
      requires default_initializable<iter_value_t<I>>
    I uninitialized_value_construct_n(Ep&& exec, I first, // freestanding-deleted
                                      iter_difference_t<I> n);
  }

  template<class InputIter, class NoThrowForwardIter>
  constexpr NoThrowForwardIter uninitialized_copy(InputIter first, // freestanding
                                                  InputIter last,
                                                  NoThrowForwardIter result);
  template<class ExecutionPolicy, class ForwardIter, class NoThrowForwardIter>
  NoThrowForwardIter uninitialized_copy(ExecutionPolicy&& exec, // freestanding-deleted
                                        ForwardIter first,
                                        ForwardIter last,
                                        NoThrowForwardIter result);
  template<class InputIter, class Size, class NoThrowForwardIter>
  constexpr NoThrowForwardIter uninitialized_copy_n(InputIter first, // freestanding
                                                    Size n,
                                                    NoThrowForwardIter result);
  template<class ExecutionPolicy,
           class ForwardIter,
           class Size,
           class NoThrowForwardIter>
  NoThrowForwardIter uninitialized_copy_n(ExecutionPolicy&& exec, // freestanding-deleted
                                          ForwardIter first,
                                          Size n,
                                          NoThrowForwardIter result);

  namespace ranges {
    template<class I, class O>
    using uninitialized_copy_result = in_out_result<I, O>; // freestanding
    template<input_iterator I,
             sentinel_for<I> S1,
             no-throw-forward-iterator O,
             no-throw-sentinel-for<O> S2>
      requires constructible_from<iter_value_t<O>, iter_reference_t<I>>
    constexpr uninitialized_copy_result<I, O>
    uninitialized_copy(I ifirst, S1 ilast, O ofirst, S2 olast); // freestanding
    template<input_range IR, no-throw-forward-range OR>
      requires constructible_from<range_value_t<OR>, range_reference_t<IR>>
    constexpr uninitialized_copy_result<borrowed_iterator_t<IR>, borrowed_iterator_t<OR>>
    uninitialized_copy(IR&& in_range, OR&& out_range); // freestanding

    template<class I, class O>
    using uninitialized_copy_n_result = in_out_result<I, O>; // freestanding
    template<input_iterator I,
             no-throw-forward-iterator O,
             no-throw-sentinel-for<O> S>
      requires constructible_from<iter_value_t<O>, iter_reference_t<I>>
    constexpr uninitialized_copy_n_result<I, O> uninitialized_copy_n(
      I ifirst,
      iter_difference_t<I> n, // freestanding
      O ofirst,
      S olast);

    template<execution-policy Ep, random_access_iterator I, sized_sentinel_for<I> S1,
             nothrow-random-access-iterator O, nothrow-sized-sentinel-for <O> S2>
      requires constructible_from<iter_value_t<O>, iter_reference_t<I>>
    uninitialized_copy_result<I, O>
      uninitialized_copy(Ep&& exec, I ifirst, S1 ilast, // freestanding-deleted
                         O ofirst, S2 olast);
    template<execution-policy Ep, sized-random-access-range IR,
             nothrow-sized-random-access-range OR>
      requires constructible_from<range_value_t<OR>, range_reference_t<IR>>
    uninitialized_copy_result<borrowed_iterator_t<IR>, borrowed_iterator_t<OR>>
      uninitialized_copy(Ep&& exec, IR&& in_range, OR&& out_range); // freestanding-deleted

    template<execution-policy Ep, random_access_iterator I,
             nothrow-random-access-iterator O, nothrow-sized-sentinel-for <O> S>
      requires constructible_from<iter_value_t<O>, iter_reference_t<I>>
    uninitialized_copy_n_result<I, O>
      uninitialized_copy_n(Ep&& exec, I ifirst, // freestanding-deleted
                           iter_difference_t<I> n, O ofirst, S olast);
  }

  template<class InputIter, class NoThrowForwardIter>
  constexpr NoThrowForwardIter uninitialized_move(InputIter first, // freestanding
                                                  InputIter last,
                                                  NoThrowForwardIter result);
  template<class ExecutionPolicy, class ForwardIter, class NoThrowForwardIter>
  NoThrowForwardIter uninitialized_move(ExecutionPolicy&& exec, // freestanding-deleted
                                        ForwardIter first,
                                        ForwardIter last,
                                        NoThrowForwardIter result);

  template<class InputIter, class Size, class NoThrowForwardIter>
  constexpr pair<InputIter, NoThrowForwardIter> uninitialized_move_n(
    InputIter first,
    Size n, // freestanding
    NoThrowForwardIter result);
  template<class ExecutionPolicy, class ForwardIter, class Size, class NoThrowForwardIter>
  pair<ForwardIter, NoThrowForwardIter> uninitialized_move_n(
    ExecutionPolicy&& exec, // freestanding-deleted
    ForwardIter first,
    Size n,
    NoThrowForwardIter result);

  namespace ranges {
    template<class I, class O>
    using uninitialized_move_result = in_out_result<I, O>; // freestanding
    template<input_iterator I,
             sentinel_for<I> S1,
             no-throw-forward-iterator O,
             no-throw-sentinel-for<O> S2>
      requires constructible_from<iter_value_t<O>, iter_rvalue_reference_t<I>>
    constexpr uninitialized_move_result<I, O>
    uninitialized_move(I ifirst, S1 ilast, O ofirst, S2 olast); // freestanding
    template<input_range IR, no-throw-forward-range OR>
      requires constructible_from<range_value_t<OR>, range_rvalue_reference_t<IR>>
    constexpr uninitialized_move_result<borrowed_iterator_t<IR>, borrowed_iterator_t<OR>>
    uninitialized_move(IR&& in_range, OR&& out_range); // freestanding

    template<class I, class O>
    using uninitialized_move_n_result = in_out_result<I, O>; // freestanding
    template<input_iterator I,
             no-throw-forward-iterator O,
             no-throw-sentinel-for<O> S>
      requires constructible_from<iter_value_t<O>, iter_rvalue_reference_t<I>>
    constexpr uninitialized_move_n_result<I, O> uninitialized_move_n(
      I ifirst,
      iter_difference_t<I> n, // freestanding
      O ofirst,
      S olast);

    template<execution-policy Ep, random_access_iterator I, sized_sentinel_for<I> S1,
             nothrow-random-access-iterator O, nothrow-sized-sentinel-for <O> S2>
      requires constructible_from<iter_value_t<O>, iter_rvalue_reference_t<I>>
    uninitialized_move_result<I, O>
      uninitialized_move(Ep&& exec, I ifirst, S1 ilast, // freestanding-deleted
                         O ofirst, S2 olast);
    template<execution-policy Ep, sized-random-access-range IR,
             nothrow-sized-random-access-range OR>
      requires constructible_from<range_value_t<OR>, range_rvalue_reference_t<IR>>
    uninitialized_move_result<borrowed_iterator_t<IR>, borrowed_iterator_t<OR>>
      uninitialized_move(Ep&& exec, IR&& in_range, OR&& out_range); // freestanding-deleted

    template<execution-policy Ep, random_access_iterator I,
             nothrow-random-access-iterator O, nothrow-sized-sentinel-for <O> S>
      requires constructible_from<iter_value_t<O>, iter_rvalue_reference_t<I>>
    uninitialized_move_n_result<I, O>
      uninitialized_move_n(Ep&& exec, I ifirst, // freestanding-deleted
                           iter_difference_t<I> n, O ofirst, S olast);
  }

  template<class NoThrowForwardIter, class T>
  constexpr void uninitialized_fill(NoThrowForwardIter first, // freestanding
                                    NoThrowForwardIter last,
                                    const T& x);
  template<class ExecutionPolicy, class NoThrowForwardIter, class T>
  void uninitialized_fill(ExecutionPolicy&& exec, // freestanding-deleted
                          NoThrowForwardIter first,
                          NoThrowForwardIter last,
                          const T& x);

  template<class NoThrowForwardIter, class Size, class T>
  constexpr NoThrowForwardIter uninitialized_fill_n(NoThrowForwardIter first,
                                                    Size n,
                                                    const T& x); // freestanding
  template<class ExecutionPolicy, class NoThrowForwardIter, class Size, class T>
  NoThrowForwardIter uninitialized_fill_n(ExecutionPolicy&& exec, // freestanding-deleted
                                          NoThrowForwardIter first,
                                          Size n,
                                          const T& x);

  namespace ranges {
    template<no-throw-forward-iterator I, no-throw-sentinel-for<I> S, class T>
      requires constructible_from<iter_value_t<I>, const T&>
    constexpr I uninitialized_fill(I first, S last, const T& x); // freestanding
    template<no-throw-forward-range R, class T>
      requires constructible_from<range_value_t<R>, const T&>
    constexpr borrowed_iterator_t<R> uninitialized_fill(R&& r,
                                                        const T& x); // freestanding

    template<no-throw-forward-iterator I, class T>
      requires constructible_from<iter_value_t<I>, const T&>
    constexpr I uninitialized_fill_n(I first, // freestanding
                                     iter_difference_t<I> n,
                                     const T& x);

    template<execution-policy Ep, nothrow-random-access-iterator I,
             nothrow-sized-sentinel-for <I> S, class T = iter_value_t<I>>
      requires constructible_from<iter_value_t<I>, const T&>
    I uninitialized_fill(Ep&& exec, I first, S last, const T& x); // freestanding-deleted
    template<execution-policy Ep, nothrow-sized-random-access-range R,
             class T = range_value_t<R>>
      requires constructible_from<range_value_t<R>, const T&>
    borrowed_iterator_t<R> uninitialized_fill(Ep&& exec, R&& r, // freestanding-deleted
                                              const T& x);

    template<execution-policy Ep, nothrow-random-access-iterator I,
             class T = iter_value_t<I>>
      requires constructible_from<iter_value_t<I>, const T&>
    I uninitialized_fill_n(Ep&& exec, I first, // freestanding-deleted
                           iter_difference_t<I> n, const T& x);
  }

  // construct_at
  template<class T, class... Args>
  constexpr T* construct_at(T* location, Args&&... args); // freestanding

  namespace ranges {
    template<class T, class... Args>
    constexpr T* construct_at(T* location, Args&&... args); // freestanding
  }

  // destroy
  template<class T>
  constexpr void destroy_at(T* location); // freestanding
  template<class NoThrowForwardIter>
  constexpr void destroy(NoThrowForwardIter first, // freestanding
                         NoThrowForwardIter last);
  template<class ExecutionPolicy, class NoThrowForwardIter>
  void destroy(ExecutionPolicy&& exec, // freestanding-deleted
               NoThrowForwardIter first,
               NoThrowForwardIter last);
  template<class NoThrowForwardIter, class Size>
  constexpr NoThrowForwardIter destroy_n(NoThrowForwardIter first, // freestanding
                                         Size n);
  template<class ExecutionPolicy, class NoThrowForwardIter, class Size>
  NoThrowForwardIter destroy_n(ExecutionPolicy&& exec, // freestanding-deleted
                               NoThrowForwardIter first,
                               Size n);

  namespace ranges {
    template<destructible T>
    constexpr void destroy_at(T* location) noexcept; // freestanding

    template<no-throw-input-iterator I, no-throw-sentinel-for<I> S>
      requires destructible<iter_value_t<I>>
    constexpr I destroy(I first, S last) noexcept; // freestanding
    template<no-throw-input-range R>
      requires destructible<range_value_t<R>>
    constexpr borrowed_iterator_t<R> destroy(R&& r) noexcept; // freestanding

    template<no-throw-input-iterator I>
      requires destructible<iter_value_t<I>>
    constexpr I destroy_n(I first, iter_difference_t<I> n) noexcept; // freestanding

    template<execution-policy Ep, nothrow-random-access-iterator I,
             nothrow-sized-sentinel-for <I> S>
      requires destructible<iter_value_t<I>>
    I destroy(Ep&& exec, I first, S last); // freestanding-deleted
    template<execution-policy Ep, nothrow-sized-random-access-range R>
      requires destructible<range_value_t<R>>
    borrowed_iterator_t<R> destroy(Ep&& exec, R&& r); // freestanding-deleted

    template<execution-policy Ep, nothrow-random-access-iterator I>
      requires destructible<iter_value_t<I>>
    I destroy_n(Ep&& exec, I first, iter_difference_t<I> n); // freestanding-deleted
  }

  // class template unique_ptr
  template<class T>
  struct default_delete; // freestanding
  template<class T>
  struct default_delete<T[]>; // freestanding
  template<class T, class D = default_delete<T>>
  class unique_ptr; // freestanding
  template<class T, class D>
  class unique_ptr<T[], D>; // freestanding

  template<class T, class... Args>
  constexpr unique_ptr<T> make_unique(Args&&... args); // T is not array
  template<class T>
  constexpr unique_ptr<T> make_unique(size_t n); // T is U[]
  template<class T, class... Args>
  /* unspecified */ make_unique(Args&&...) = delete; // T is U[N]

  template<class T>
  constexpr unique_ptr<T> make_unique_for_overwrite(); // T is not array
  template<class T>
  constexpr unique_ptr<T> make_unique_for_overwrite(size_t n); // T is U[]
  template<class T, class... Args>
  /* unspecified */ make_unique_for_overwrite(Args&&...) = delete; // T is U[N]

  template<class T, class D>
  constexpr void swap(unique_ptr<T, D>& x, unique_ptr<T, D>& y) noexcept; // freestanding

  template<class T1, class D1, class T2, class D2>
  constexpr bool operator==(const unique_ptr<T1, D1>& x, // freestanding
                            const unique_ptr<T2, D2>& y);
  template<class T1, class D1, class T2, class D2>
  constexpr bool operator<(const unique_ptr<T1, D1>& x,
                           const unique_ptr<T2, D2>& y); // freestanding
  template<class T1, class D1, class T2, class D2>
  constexpr bool operator>(const unique_ptr<T1, D1>& x,
                           const unique_ptr<T2, D2>& y); // freestanding
  template<class T1, class D1, class T2, class D2>
  constexpr bool operator<=(const unique_ptr<T1, D1>& x,
                            const unique_ptr<T2, D2>& y); // freestanding
  template<class T1, class D1, class T2, class D2>
  constexpr bool operator>=(const unique_ptr<T1, D1>& x,
                            const unique_ptr<T2, D2>& y); // freestanding
  template<class T1, class D1, class T2, class D2>
    requires three_way_comparable_with<typename unique_ptr<T1, D1>::pointer,
                                       typename unique_ptr<T2, D2>::pointer>
  constexpr compare_three_way_result_t<typename unique_ptr<T1, D1>::pointer,
                                       typename unique_ptr<T2, D2>::pointer>
  operator<=>(const unique_ptr<T1, D1>& x, const unique_ptr<T2, D2>& y); // freestanding

  template<class T, class D>
  constexpr bool operator==(const unique_ptr<T, D>& x,
                            nullptr_t) noexcept; // freestanding
  template<class T, class D>
  constexpr bool operator<(const unique_ptr<T, D>& x, nullptr_t); // freestanding
  template<class T, class D>
  constexpr bool operator<(nullptr_t, const unique_ptr<T, D>& y); // freestanding
  template<class T, class D>
  constexpr bool operator>(const unique_ptr<T, D>& x, nullptr_t); // freestanding
  template<class T, class D>
  constexpr bool operator>(nullptr_t, const unique_ptr<T, D>& y); // freestanding
  template<class T, class D>
  constexpr bool operator<=(const unique_ptr<T, D>& x, nullptr_t); // freestanding
  template<class T, class D>
  constexpr bool operator<=(nullptr_t, const unique_ptr<T, D>& y); // freestanding
  template<class T, class D>
  constexpr bool operator>=(const unique_ptr<T, D>& x, nullptr_t); // freestanding
  template<class T, class D>
  constexpr bool operator>=(nullptr_t, const unique_ptr<T, D>& y); // freestanding
  template<class T, class D>
    requires three_way_comparable<typename unique_ptr<T, D>::pointer>
  constexpr compare_three_way_result_t<typename unique_ptr<T, D>::pointer> operator<=>(
    const unique_ptr<T, D>& x,
    nullptr_t); // freestanding

  template<class E, class T, class Y, class D>
  basic_ostream<E, T>& operator<<(basic_ostream<E, T>& os, const unique_ptr<Y, D>& p);

  // class bad_weak_ptr
  class bad_weak_ptr;

  // class template shared_ptr
  template<class T>
  class shared_ptr;

  // shared_ptr creation
  template<class T, class... Args>
  constexpr shared_ptr<T> make_shared(Args&&... args); // T is not array
  template<class T, class A, class... Args>
  sconstexpr hared_ptr<T> allocate_shared(const A& a, Args&&... args); // T is not array

  template<class T>
  constexpr shared_ptr<T> make_shared(size_t N); // T is U[]
  template<class T, class A>
  constexpr shared_ptr<T> allocate_shared(const A& a, size_t N); // T is U[]

  template<class T>
  constexpr shared_ptr<T> make_shared(); // T is U[N]
  template<class T, class A>
  constexpr shared_ptr<T> allocate_shared(const A& a); // T is U[N]

  template<class T>
  constexpr shared_ptr<T> make_shared(size_t N, const remove_extent_t<T>& u); // T is U[]
  template<class T, class A>
  constexpr shared_ptr<T> allocate_shared(const A& a,
                                          size_t N,
                                          const remove_extent_t<T>& u); // T is U[]

  template<class T>
  constexpr shared_ptr<T> make_shared(const remove_extent_t<T>& u); // T is U[N]
  template<class T, class A>
  constexpr shared_ptr<T> allocate_shared(const A& a,
                                          const remove_extent_t<T>& u); // T is U[N]

  template<class T>
  constexpr shared_ptr<T> make_shared_for_overwrite(); // T is not U[]
  template<class T, class A>
  constexpr shared_ptr<T> allocate_shared_for_overwrite(const A& a); // T is not U[]

  template<class T>
  constexpr shared_ptr<T> make_shared_for_overwrite(size_t N); // T is U[]
  template<class T, class A>
  constexpr shared_ptr<T> allocate_shared_for_overwrite(const A& a, size_t N); // T is U[]

  // shared_ptr comparisons
  template<class T, class U>
  constexpr bool operator==(const shared_ptr<T>& a, const shared_ptr<U>& b) noexcept;
  template<class T, class U>
  constexpr strong_ordering operator<=>(const shared_ptr<T>& a,
                                        const shared_ptr<U>& b) noexcept;

  template<class T>
  constexpr bool operator==(const shared_ptr<T>& x, nullptr_t) noexcept;
  template<class T>
  constexpr strong_ordering operator<=>(const shared_ptr<T>& x, nullptr_t) noexcept;

  // shared_ptr specialized algorithms
  template<class T>
  constexpr void swap(shared_ptr<T>& a, shared_ptr<T>& b) noexcept;

  // shared_ptr casts
  template<class T, class U>
  constexpr shared_ptr<T> static_pointer_cast(const shared_ptr<U>& r) noexcept;
  template<class T, class U>
  constexpr shared_ptr<T> static_pointer_cast(shared_ptr<U>&& r) noexcept;
  template<class T, class U>
  constexpr shared_ptr<T> dynamic_pointer_cast(const shared_ptr<U>& r) noexcept;
  template<class T, class U>
  constexpr shared_ptr<T> dynamic_pointer_cast(shared_ptr<U>&& r) noexcept;
  template<class T, class U>
  constexpr shared_ptr<T> const_pointer_cast(const shared_ptr<U>& r) noexcept;
  template<class T, class U>
  constexpr shared_ptr<T> const_pointer_cast(shared_ptr<U>&& r) noexcept;
  template<class T, class U>
  shared_ptr<T> reinterpret_pointer_cast(const shared_ptr<U>& r) noexcept;
  template<class T, class U>
  shared_ptr<T> reinterpret_pointer_cast(shared_ptr<U>&& r) noexcept;

  // shared_ptr get_deleter
  template<class D, class T>
  constexpr D* get_deleter(const shared_ptr<T>& p) noexcept;

  // shared_ptr I/O
  template<class E, class T, class Y>
  basic_ostream<E, T>& operator<<(basic_ostream<E, T>& os, const shared_ptr<Y>& p);

  // class template weak_ptr
  template<class T>
  class weak_ptr;

  // weak_ptr specialized algorithms
  template<class T>
  constexpr void swap(weak_ptr<T>& a, weak_ptr<T>& b) noexcept;

  // class template owner_less
  template<class T = void>
  struct owner_less;

  // struct owner_hash
  struct owner_hash;

  // struct owner_equal
  struct owner_equal;

  // class template enable_shared_from_this
  template<class T>
  class enable_shared_from_this;

  // hash support
  template<class T>
  struct hash; // freestanding
  template<class T, class D>
  struct hash<unique_ptr<T, D>>; // freestanding
  template<class T>
  struct hash<shared_ptr<T>>;

  // atomic smart pointers
  template<class T>
  struct atomic; // freestanding
  template<class T>
  struct atomic<shared_ptr<T>>;
  template<class T>
  struct atomic<weak_ptr<T>>;

  // class template out_ptr_t
  template<class Smart, class Pointer, class... Args>
  class out_ptr_t; // freestanding

  // function template out_ptr
  template<class Pointer = void, class Smart, class... Args>
  constexpr auto out_ptr(Smart& s, Args&&... args); // freestanding

  // class template inout_ptr_t
  template<class Smart, class Pointer, class... Args>
  class inout_ptr_t; // freestanding

  // function template inout_ptr
  template<class Pointer = void, class Smart, class... Args>
  constexpr auto inout_ptr(Smart& s, Args&&... args); // freestanding

  // class template indirect
  template<class T, class Allocator = allocator<T>>
  class indirect;

  // hash support
  template<class T, class Alloc>
  struct hash<indirect<T, Alloc>>;

  // class template polymorphic
  template<class T, class Allocator = allocator<T>>
  class polymorphic;

  namespace pmr {
    template<class T>
    using indirect = indirect<T, polymorphic_allocator<T>>;
    template<class T>
    using polymorphic = polymorphic<T, polymorphic_allocator<T>>;
  }
}

Modèle de classe std::pointer_traits

namespace std {
  template<class Ptr>
  struct pointer_traits
  {
    /* voir description */;
  };
  template<class T>
  struct pointer_traits<T*>
  {
    using pointer         = T*;
    using element_type    = T;
    using difference_type = ptrdiff_t;
    template<class U>
    using rebind = U*;
    static constexpr pointer pointer_to(/* voir description */ r) noexcept;
  };
}

Classe std::allocator_arg_t

namespace std {
  struct allocator_arg_t { explicit allocator_arg_t() = default; };
  inline constexpr allocator_arg_t allocator_arg{};
}

**Note:** Le code C++ n'a pas été traduit conformément aux instructions, car il se trouve dans des balises `

` et contient des termes spécifiques au C++. Seul le texte environnant aurait été traduit s'il y en avait eu.

Modèle de classe std::allocator_traits

namespace std {
  template<class Alloc>
  struct allocator_traits
  {
    using allocator_type                         = Alloc;
    using value_type                             = typename Alloc::value_type;
    using pointer                                = /* voir description */;
    using const_pointer                          = /* voir description */;
    using void_pointer                           = /* voir description */;
    using const_void_pointer                     = /* voir description */;
    using difference_type                        = /* voir description */;
    using size_type                              = /* voir description */;
    using propagate_on_container_copy_assignment = /* voir description */;
    using propagate_on_container_move_assignment = /* voir description */;
    using propagate_on_container_swap            = /* voir description */;
    using is_always_equal                        = /* voir description */;
    template<class T>
    using rebind_alloc = /* voir description */;
    template<class T>
    using rebind_traits = allocator_traits<rebind_alloc<T>>;
    static constexpr pointer allocate(Alloc& a, size_type n);
    static constexpr pointer allocate(Alloc& a, size_type n, const_void_pointer hint);
    static constexpr allocation_result<pointer, size_type> allocate_at_least(Alloc& a,
                                                                             size_type n);
    static constexpr void deallocate(Alloc& a, pointer p, size_type n);
    template<class T, class... Args>
    static constexpr void construct(Alloc& a, T* p, Args&&... args);
    template<class T>
    static constexpr void destroy(Alloc& a, T* p);
    static constexpr size_type max_size(const Alloc& a) noexcept;
    static constexpr Alloc select_on_container_copy_construction(const Alloc& rhs);
  };
}

Modèle de classe std::allocator

namespace std {
  template<class T>
  class allocator
  {
  public:
    using value_type                             = T;
    using size_type                              = size_t;
    using difference_type                        = ptrdiff_t;
    using propagate_on_container_move_assignment = true_type;
    constexpr allocator() noexcept;
    constexpr allocator(const allocator&) noexcept;
    template<class U>
    constexpr allocator(const allocator<U>&) noexcept;
    constexpr ~allocator();
    constexpr allocator& operator=(const allocator&) = default;
    constexpr T* allocate(size_t n);
    constexpr allocation_result<T*> allocate_at_least(size_t n);
    constexpr void deallocate(T* p, size_t n);
  };
}

Le code C++ reste inchangé comme demandé, car il se trouve dans des balises `

` et contient des termes spécifiques au C++ qui ne doivent pas être traduits. Seul le texte en dehors des balises de code aurait été traduit, mais dans ce cas, il n'y a pas de texte supplémentaire à traduire.

Modèle de classe std::default_delete

namespace std {
  template<class T>
  struct default_delete
  {
    constexpr default_delete() noexcept = default;
    template<class U>
    constexpr default_delete(const default_delete<U>&) noexcept;
    constexpr void operator()(T*) const;
  };
  template<class T>
  struct default_delete<T[]>
  {
    constexpr default_delete() noexcept = default;
    template<class U>
    constexpr default_delete(const default_delete<U[]>&) noexcept;
    template<class U>
    constexpr void operator()(U* ptr) const;
  };
}

Modèle de classe std::unique_ptr

namespace std {
  template<class T, class D = default_delete<T>>
  class unique_ptr
  {
  public:
    using pointer      = /* voir description */;
    using element_type = T;
    using deleter_type = D;
    // constructeurs
    constexpr unique_ptr() noexcept;
    constexpr explicit unique_ptr(type_identity_t<pointer> p) noexcept;
    constexpr unique_ptr(type_identity_t<pointer> p, /* voir description */ d1) noexcept;
    constexpr unique_ptr(type_identity_t<pointer> p, /* voir description */ d2) noexcept;
    constexpr unique_ptr(unique_ptr&& u) noexcept;
    constexpr unique_ptr(nullptr_t) noexcept;
    template<class U, class E>
    constexpr unique_ptr(unique_ptr<U, E>&& u) noexcept;
    // destructeur
    constexpr ~unique_ptr();
    // affectation
    constexpr unique_ptr& operator=(unique_ptr&& u) noexcept;
    template<class U, class E>
    constexpr unique_ptr& operator=(unique_ptr<U, E>&& u) noexcept;
    constexpr unique_ptr& operator=(nullptr_t) noexcept;
    // observateurs
    constexpr add_lvalue_reference_t<T> operator*() const noexcept(/* voir description */);
    constexpr pointer operator->() const noexcept;
    constexpr pointer get() const noexcept;
    constexpr deleter_type& get_deleter() noexcept;
    constexpr const deleter_type& get_deleter() const noexcept;
    constexpr explicit operator bool() const noexcept;
    // modificateurs
    constexpr pointer release() noexcept;
    constexpr void reset(pointer p = pointer()) noexcept;
    constexpr void swap(unique_ptr& u) noexcept;
    // désactiver la copie à partir d'une lvalue
    unique_ptr(const unique_ptr&)            = delete;
    unique_ptr& operator=(const unique_ptr&) = delete;
  };
  template<class T, class D>
  class unique_ptr<T[], D>
  {
  public:
    using pointer      = /* voir description */;
    using element_type = T;
    using deleter_type = D;
    // constructeurs
    constexpr unique_ptr() noexcept;
    template<class U>
    constexpr explicit unique_ptr(U p) noexcept;
    template<class U>
    constexpr unique_ptr(U p, /* voir description */ d) noexcept;
    template<class U>
    constexpr unique_ptr(U p, /* voir description */ d) noexcept;
    constexpr unique_ptr(unique_ptr&& u) noexcept;
    template<class U, class E>
    constexpr unique_ptr(unique_ptr<U, E>&& u) noexcept;
    constexpr unique_ptr(nullptr_t) noexcept;
    // destructeur
    constexpr ~unique_ptr();
    // affectation
    constexpr unique_ptr& operator=(unique_ptr&& u) noexcept;
    template<class U, class E>
    constexpr unique_ptr& operator=(unique_ptr<U, E>&& u) noexcept;
    constexpr unique_ptr& operator=(nullptr_t) noexcept;
    // observateurs
    constexpr T& operator[](size_t i) const;
    constexpr pointer get() const noexcept;
    constexpr deleter_type& get_deleter() noexcept;
    constexpr const deleter_type& get_deleter() const noexcept;
    constexpr explicit operator bool() const noexcept;
    // modificateurs
    constexpr pointer release() noexcept;
    template<class U>
    constexpr void reset(U p) noexcept;
    constexpr void reset(nullptr_t = nullptr) noexcept;
    constexpr void swap(unique_ptr& u) noexcept;
    // désactiver la copie à partir d'une lvalue
    unique_ptr(const unique_ptr&)            = delete;
    unique_ptr& operator=(const unique_ptr&) = delete;
  };
}

Classe std::bad_weak_ptr

namespace std {
  class bad_weak_ptr : public exception
  {
  public:
    // pour la spécification des fonctions membres spéciales
    const char* what() const noexcept override;
  };
}

Modèle de classe std::shared_ptr

namespace std {
  template<class T>
  class shared_ptr
  {
  public:
    using element_type = remove_extent_t<T>;
    using weak_type    = weak_ptr<T>;
    // constructeurs
    constexpr shared_ptr() noexcept;
    constexpr shared_ptr(nullptr_t) noexcept
      : shared_ptr()
    {
    }
    template<class Y>
    explicit shared_ptr(Y* p);
    template<class Y, class D>
    shared_ptr(Y* p, D d);
    template<class Y, class D, class A>
    shared_ptr(Y* p, D d, A a);
    template<class D>
    shared_ptr(nullptr_t p, D d);
    template<class D, class A>
    shared_ptr(nullptr_t p, D d, A a);
    template<class Y>
    shared_ptr(const shared_ptr<Y>& r, element_type* p) noexcept;
    template<class Y>
    shared_ptr(shared_ptr<Y>&& r, element_type* p) noexcept;
    shared_ptr(const shared_ptr& r) noexcept;
    template<class Y>
    shared_ptr(const shared_ptr<Y>& r) noexcept;
    shared_ptr(shared_ptr&& r) noexcept;
    template<class Y>
    shared_ptr(shared_ptr<Y>&& r) noexcept;
    template<class Y>
    explicit shared_ptr(const weak_ptr<Y>& r);
    template<class Y, class D>
    shared_ptr(unique_ptr<Y, D>&& r);
    // destructeur
    ~shared_ptr();
    // affectation
    shared_ptr& operator=(const shared_ptr& r) noexcept;
    template<class Y>
    shared_ptr& operator=(const shared_ptr<Y>& r) noexcept;
    shared_ptr& operator=(shared_ptr&& r) noexcept;
    template<class Y>
    shared_ptr& operator=(shared_ptr<Y>&& r) noexcept;
    template<class Y, class D>
    shared_ptr& operator=(unique_ptr<Y, D>&& r);
    // modificateurs
    void swap(shared_ptr& r) noexcept;
    void reset() noexcept;
    template<class Y>
    void reset(Y* p);
    template<class Y, class D>
    void reset(Y* p, D d);
    template<class Y, class D, class A>
    void reset(Y* p, D d, A a);
    // observateurs
    element_type* get() const noexcept;
    T& operator*() const noexcept;
    T* operator->() const noexcept;
    element_type& operator[](ptrdiff_t i) const;
    long use_count() const noexcept;
    explicit operator bool() const noexcept;
    template<class U>
    bool owner_before(const shared_ptr<U>& b) const noexcept;
    template<class U>
    bool owner_before(const weak_ptr<U>& b) const noexcept;
    size_t owner_hash() const noexcept;
    template<class U>
    bool owner_equal(const shared_ptr<U>& b) const noexcept;
    template<class U>
    bool owner_equal(const weak_ptr<U>& b) const noexcept;
  };
  template<class T>
  shared_ptr(weak_ptr<T>) -> shared_ptr<T>;
  template<class T, class D>
  shared_ptr(unique_ptr<T, D>) -> shared_ptr<T>;
}

Modèle de classe std::weak_ptr

namespace std {
  template<class T>
  class weak_ptr
  {
  public:
    using element_type = remove_extent_t<T>;
    // constructeurs
    constexpr weak_ptr() noexcept;
    template<class Y>
    weak_ptr(const shared_ptr<Y>& r) noexcept;
    weak_ptr(const weak_ptr& r) noexcept;
    template<class Y>
    weak_ptr(const weak_ptr<Y>& r) noexcept;
    weak_ptr(weak_ptr&& r) noexcept;
    template<class Y>
    weak_ptr(weak_ptr<Y>&& r) noexcept;
    // destructeur
    ~weak_ptr();
    // assignation
    weak_ptr& operator=(const weak_ptr& r) noexcept;
    template<class Y>
    weak_ptr& operator=(const weak_ptr<Y>& r) noexcept;
    template<class Y>
    weak_ptr& operator=(const shared_ptr<Y>& r) noexcept;
    weak_ptr& operator=(weak_ptr&& r) noexcept;
    template<class Y>
    weak_ptr& operator=(weak_ptr<Y>&& r) noexcept;
    // modificateurs
    void swap(weak_ptr& r) noexcept;
    void reset() noexcept;
    // observateurs
    long use_count() const noexcept;
    bool expired() const noexcept;
    shared_ptr<T> lock() const noexcept;
    template<class U>
    bool owner_before(const shared_ptr<U>& b) const noexcept;
    template<class U>
    bool owner_before(const weak_ptr<U>& b) const noexcept;
    size_t owner_hash() const noexcept;
    template<class U>
    bool owner_equal(const shared_ptr<U>& b) const noexcept;
    template<class U>
    bool owner_equal(const weak_ptr<U>& b) const noexcept;
  };
  template<class T>
  weak_ptr(shared_ptr<T>) -> weak_ptr<T>;
}

Modèle de classe std::owner_less

namespace std {
  template<class T = void>
  struct owner_less;
  template<class T>
  struct owner_less<shared_ptr<T>>
  {
    bool operator()(const shared_ptr<T>&, const shared_ptr<T>&) const noexcept;
    bool operator()(const shared_ptr<T>&, const weak_ptr<T>&) const noexcept;
    bool operator()(const weak_ptr<T>&, const shared_ptr<T>&) const noexcept;
  };
  template<class T>
  struct owner_less<weak_ptr<T>>
  {
    bool operator()(const weak_ptr<T>&, const weak_ptr<T>&) const noexcept;
    bool operator()(const shared_ptr<T>&, const weak_ptr<T>&) const noexcept;
    bool operator()(const weak_ptr<T>&, const shared_ptr<T>&) const noexcept;
  };
  template<>
  struct owner_less<void>
  {
    template<class T, class U>
    bool operator()(const shared_ptr<T>&, const shared_ptr<U>&) const noexcept;
    template<class T, class U>
    bool operator()(const shared_ptr<T>&, const weak_ptr<U>&) const noexcept;
    template<class T, class U>
    bool operator()(const weak_ptr<T>&, const shared_ptr<U>&) const noexcept;
    template<class T, class U>
    bool operator()(const weak_ptr<T>&, const weak_ptr<U>&) const noexcept;
    using is_transparent = /* non spécifié */;
  };
}

Classe std::owner_hash

namespace std {
  struct owner_hash
  {
    template<class T>
    size_t operator()(const shared_ptr<T>&) const noexcept;
    template<class T>
    size_t operator()(const weak_ptr<T>&) const noexcept;
    using is_transparent = /* non spécifié */;
  };
}

Classe std::owner_equal

namespace std {
  struct owner_equal
  {
    template<class T, class U>
    bool operator()(const shared_ptr<T>&, const shared_ptr<U>&) const noexcept;
    template<class T, class U>
    bool operator()(const shared_ptr<T>&, const weak_ptr<U>&) const noexcept;
    template<class T, class U>
    bool operator()(const weak_ptr<T>&, const shared_ptr<U>&) const noexcept;
    template<class T, class U>
    bool operator()(const weak_ptr<T>&, const weak_ptr<U>&) const noexcept;
    using is_transparent = /* non spécifié */;
  };
}

Modèle de classe std::enable_shared_from_this

namespace std {
  template<class T>
  class enable_shared_from_this
  {
  protected:
    constexpr enable_shared_from_this() noexcept;
    enable_shared_from_this(const enable_shared_from_this&) noexcept;
    enable_shared_from_this& operator=(const enable_shared_from_this&) noexcept;
    ~enable_shared_from_this();
  public:
    shared_ptr<T> shared_from_this();
    shared_ptr<T const> shared_from_this() const;
    weak_ptr<T> weak_from_this() noexcept;
    weak_ptr<T const> weak_from_this() const noexcept;
  private:
    mutable weak_ptr<T> /*weak-this*/; // exposition uniquement
  };
}

Spécialisation du modèle de classe std::atomic pour std::shared_ptr

namespace std {
  template<class T> struct atomic<shared_ptr<T>> {
    using value_type = shared_ptr<T>;
    static constexpr bool is_always_lock_free = /* défini par l'implémentation */;
    bool is_lock_free() const noexcept;
    void store(shared_ptr<T> desired, memory_order order = memory_order::seq_cst) noexcept;
    shared_ptr<T> load(memory_order order = memory_order::seq_cst) const noexcept;
    operator shared_ptr<T>() const noexcept;
    shared_ptr<T> exchange(shared_ptr<T> desired,
                           memory_order order = memory_order::seq_cst) noexcept;
    bool compare_exchange_weak(shared_ptr<T>& expected, shared_ptr<T> desired,
                               memory_order success, memory_order failure) noexcept;
    bool compare_exchange_strong(shared_ptr<T>& expected, shared_ptr<T> desired,
                                 memory_order success, memory_order failure) noexcept;
    bool compare_exchange_weak(shared_ptr<T>& expected, shared_ptr<T> desired,
                               memory_order order = memory_order::seq_cst) noexcept;
    bool compare_exchange_strong(shared_ptr<T>& expected, shared_ptr<T> desired,
                                 memory_order order = memory_order::seq_cst) noexcept;
    constexpr atomic() noexcept = default;
    atomic(shared_ptr<T> desired) noexcept;
    atomic(const atomic&) = delete;
    void operator=(const atomic&) = delete;
    void operator=(shared_ptr<T> desired) noexcept;
  private:
    shared_ptr<T> p;            // exposition uniquement
  };
}

Spécialisation du modèle de classe std::atomic pour std::weak_ptr

namespace std {
  template<class T> struct atomic<weak_ptr<T>> {
    using value_type = weak_ptr<T>;
    static constexpr bool is_always_lock_free = /* défini par l'implémentation */;
    bool is_lock_free() const noexcept;
    void store(weak_ptr<T> desired, memory_order order = memory_order::seq_cst) noexcept;
    weak_ptr<T> load(memory_order order = memory_order::seq_cst) const noexcept;
    operator weak_ptr<T>() const noexcept;
    weak_ptr<T> exchange(weak_ptr<T> desired,
                         memory_order order = memory_order::seq_cst) noexcept;
    bool compare_exchange_weak(weak_ptr<T>& expected, weak_ptr<T> desired,
                               memory_order success, memory_order failure) noexcept;
    bool compare_exchange_strong(weak_ptr<T>& expected, weak_ptr<T> desired,
                                 memory_order success, memory_order failure) noexcept;
    bool compare_exchange_weak(weak_ptr<T>& expected, weak_ptr<T> desired,
                               memory_order order = memory_order::seq_cst) noexcept;
    bool compare_exchange_strong(weak_ptr<T>& expected, weak_ptr<T> desired,
                                 memory_order order = memory_order::seq_cst) noexcept;
    constexpr atomic() noexcept = default;
    atomic(weak_ptr<T> desired) noexcept;
    atomic(const atomic&) = delete;
    void operator=(const atomic&) = delete;
    void operator=(weak_ptr<T> desired) noexcept;
  private:
    weak_ptr<T> p;              // exposition uniquement
  };
}

Modèle de classe std:: out_ptr_t

namespace std {
  template<class Smart, class Pointer, class... Args>
  class out_ptr_t
  {
  public:
    explicit out_ptr_t(Smart&, Args...);
    out_ptr_t(const out_ptr_t&) = delete;
    ~out_ptr_t();
    operator Pointer*() const noexcept;
    operator void**() const noexcept;
  private:
    Smart& s;         // exposition uniquement
    tuple<Args...> a; // exposition uniquement
    Pointer p;        // exposition uniquement
  };
}

Modèle de classe std:: inout_ptr_t

namespace std {
  template<class Smart, class Pointer, class... Args>
  class inout_ptr_t
  {
  public:
    explicit inout_ptr_t(Smart&, Args...);
    inout_ptr_t(const inout_ptr_t&) = delete;
    ~inout_ptr_t();
    operator Pointer*() const noexcept;
    operator void**() const noexcept;
  private:
    Smart& s;         // exposition uniquement
    tuple<Args...> a; // exposition uniquement
    Pointer p;        // exposition uniquement
  };
}

Modèle de classe std :: indirect

namespace std {
  template<class T, class Allocator = allocator<T>>
  class indirect
  {
  public:
    using value_type     = T;
    using allocator_type = Allocator;
    using pointer        = typename allocator_traits<Allocator>::pointer;
    using const_pointer  = typename allocator_traits<Allocator>::const_pointer;
    // constructeurs
    constexpr explicit indirect();
    constexpr explicit indirect(allocator_arg_t, const Allocator& a);
    constexpr indirect(const indirect& other);
    constexpr indirect(allocator_arg_t, const Allocator& a, const indirect& other);
    constexpr indirect(indirect&& other) noexcept;
    constexpr indirect(allocator_arg_t,
                       const Allocator& a,
                       indirect&& other) noexcept(/* voir description */);
    template<class U = T>
    constexpr explicit indirect(U&& u);
    template<class U = T>
    constexpr explicit indirect(allocator_arg_t, const Allocator& a, U&& u);
    template<class... Nous>
    constexpr explicit indirect(in_place_t, Us&&... us);
    template<class... Nous>
    constexpr explicit indirect(allocator_arg_t,
                                const Allocator& a,
                                in_place_t,
                                Us&&... us);
    template<class I, class... Nous>
    constexpr explicit indirect(in_place_t, initializer_list<I> ilist, Us&&... us);
    template<class I, class... Nous>
    constexpr explicit indirect(allocator_arg_t,
                                const Allocator& a,
                                in_place_t,
                                initializer_list<I> ilist,
                                Us&&... us);
    // destructeur
    constexpr ~indirect();
    // affectation
    constexpr indirect& operator=(const indirect& other);
    constexpr indirect& operator=(indirect&& other) noexcept(/* voir description */);
    template<class U = T>
    constexpr indirect& operator=(U&& u);
    // observateurs
    constexpr const T& operator*() const& noexcept;
    constexpr T& operator*() & noexcept;
    constexpr const T&& operator*() const&& noexcept;
    constexpr T&& operator*() && noexcept;
    constexpr const_pointer operator->() const noexcept;
    constexpr pointer operator->() noexcept;
    constexpr bool valueless_after_move() const noexcept;
    constexpr allocator_type get_allocator() const noexcept;
    // échanger
    constexpr void swap(indirect& other) noexcept(/* voir description */);
    friend constexpr void swap(indirect& lhs,
                               indirect& rhs) noexcept(/* voir description */);
    // opérateurs relationnels
    template<class U, class AA>
    friend constexpr bool operator==(
      const indirect& lhs,
      const indirect<U, AA>& rhs) noexcept(/* voir description */);
    template<class U, class AA>
    friend constexpr auto operator<=>(const indirect& lhs, const indirect<U, AA>& rhs)
      -> /*synth-three-way-result*/<T, U>;
    // comparaison avec T
    template<class U>
    friend constexpr bool operator==(const indirect& lhs,
                                     const U& rhs) noexcept(/* voir description */);
    template<class U>
    friend constexpr auto operator<=>(const indirect& lhs, const U& rhs)
      -> /*synth-three-way-result*/<T, U>;
  private:
    pointer /*p*/;                     // exposition uniquement
    Allocator /*alloc*/ = Allocator(); // exposition uniquement
  };
  template<class Value>
  indirect(Value) -> indirect<Value>;
  template<class Allocator, class Value>
  indirect(allocator_arg_t, Allocator, Value)
    -> indirect<Value,
                typename allocator_traits<Allocator>::template rebind_alloc<Value>>;
}

Modèle de classe std :: polymorphic

namespace std {
  template<class T, class Allocator = allocator<T>>
  class polymorphic
  {
  public:
    using value_type     = T;
    using allocator_type = Allocator;
    using pointer        = typename allocator_traits<Allocator>::pointer;
    using const_pointer  = typename allocator_traits<Allocator>::const_pointer;
    // constructeurs
    constexpr explicit polymorphic();
    constexpr explicit polymorphic(allocator_arg_t, const Allocator& a);
    constexpr polymorphic(const polymorphic& other);
    constexpr polymorphic(allocator_arg_t, const Allocator& a, const polymorphic& other);
    constexpr polymorphic(polymorphic&& other) noexcept;
    constexpr polymorphic(allocator_arg_t,
                          const Allocator& a,
                          polymorphic&& other) noexcept(/* voir description */);
    template<class U = T>
    constexpr explicit polymorphic(U&& u);
    template<class U = T>
    constexpr explicit polymorphic(allocator_arg_t, const Allocator& a, U&& u);
    template<class U, class... Ts>
    constexpr explicit polymorphic(in_place_type_t<U>, Ts&&... ts);
    template<class U, class... Ts>
    constexpr explicit polymorphic(allocator_arg_t,
                                   const Allocator& a,
                                   in_place_type_t<U>,
                                   Ts&&... ts);
    template<class U, class I, class... Us>
    constexpr explicit polymorphic(in_place_type_t<U>,
                                   initializer_list<I> ilist,
                                   Us&&... us);
    template<class U, class I, class... Us>
    constexpr explicit polymorphic(allocator_arg_t,
                                   const Allocator& a,
                                   in_place_type_t<U>,
                                   initializer_list<I> ilist,
                                   Us&&... us);
    // destructeur
    constexpr ~polymorphic();
    // affectation
    constexpr polymorphic& operator=(const polymorphic& other);
    constexpr polymorphic& operator=(polymorphic&& other) noexcept(/* voir description */);
    // observateurs
    constexpr const T& operator*() const noexcept;
    constexpr T& operator*() noexcept;
    constexpr const_pointer operator->() const noexcept;
    constexpr pointer operator->() noexcept;
    constexpr bool valueless_after_move() const noexcept;
    constexpr allocator_type get_allocator() const noexcept;
    // échange
    constexpr void swap(polymorphic& other) noexcept(/* voir description */);
    friend constexpr void swap(polymorphic& lhs,
                               polymorphic& rhs) noexcept(/* voir description */);
  private:
    Allocator /*alloc*/ = Allocator(); // exposition uniquement
  };
}

Compiler support
Freestanding and hosted
Language
Standard library
Standard library headers
Named requirements
Feature test macros (C++20)
Language support library
Concepts library (C++20)
Diagnostics library
Memory management library
Metaprogramming library (C++11)
General utilities library
Containers library
Iterators library
Ranges library (C++20)
Algorithms library
Strings library
Text processing library
Numerics library
Date and time library
Input/output library
Filesystem library (C++17)
Concurrency support library (C++11)
Execution control library (C++26)
Technical specifications
Symbols index
External libraries

fr.cppreference.net

Namespaces

Variants

Standard library header <memory>

Sommaire

Inclusions

Classes

Caractéristiques des pointeurs

Prise en charge du ramasse-miettes

Allocateurs

Stockage non initialisé

Pointeurs intelligents

Adaptateurs de pointeurs intelligents

Types pour la conception de classes composites

Classes auxiliaires

Déclarations anticipées

Étiquettes

Fonctions / Entités de type fonction

Construction avec allocateur

Divers

Gestion explicite de la durée de vie