Standard library header <memory>

From cppreference.net

< cpp ‎ | header

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

Table des matières

Inclusions

(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

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)

Stockage non initialisé

uninitialized_copy

copie une série d'objets vers une zone mémoire non initialisée
(modèle de fonction)

uninitialized_copy_n

(C++11)

copie un nombre d'objets vers une zone mémoire non initialisée
(fonction template)

uninitialized_fill

copie un objet vers une zone mémoire non initialisée, définie par une plage
(modèle de fonction)

uninitialized_fill_n

copie un objet vers une zone mémoire non initialisée, définie par un début et un compteur
(modèle de fonction)

uninitialized_move

(C++17)

déplace une série d'objets vers une zone mémoire non initialisée
(modèle de fonction)

uninitialized_move_n

(C++17)

déplace un nombre d'objets vers une zone mémoire non initialisée
(modèle de fonction)

uninitialized_default_construct

(C++17)

construit des objets par default-initialization dans une zone mémoire non initialisée, définie par une plage
(modèle de fonction)

uninitialized_default_construct_n

(C++17)

construit des objets par default-initialization dans une zone mémoire non initialisée, définie par un début et un compte
(modèle de fonction)

uninitialized_value_construct

(C++17)

construit des objets par value-initialization dans une zone mémoire non initialisée, définie par une plage
(fonction template)

uninitialized_value_construct_n

(C++17)

construit des objets par value-initialization dans une zone mémoire non initialisée, définie par un début et un compte
(fonction template)

construct_at

(C++20)

crée un objet à une adresse donnée
(modèle de fonction)

destroy_at

(C++17)

détruit un objet à une adresse donnée
(fonction template)

destroy

(C++17)

détruit une série d'objets
(fonction template)

destroy_n

(C++17)

détruit un nombre d'objets dans une plage
(modèle de fonction)

get_temporary_buffer

(déprécié en C++17) (supprimé en C++20)

obtient du stockage non initialisé
(modèle de fonction)

return_temporary_buffer

(déprécié en C++17) (supprimé en C++20)

libère le 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)

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

spécialise les opérations atomiques pour


          std::shared_ptr

(modèle de fonction)

Entités de type fonction
Définies dans l'espace de noms `std::ranges`
Stockage non initialisé
ranges::uninitialized_copy (C++20)	copie une plage d'objets vers une zone mémoire non initialisée (objet fonction algorithme)
ranges::uninitialized_copy_n (C++20)	copie un nombre d'objets vers une zone mémoire non initialisée (objet fonction algorithme)
ranges::uninitialized_fill (C++20)	copie un objet vers une zone mémoire non initialisée, définie par une plage (objet fonction algorithme)
ranges::uninitialized_fill_n (C++20)	copie un objet vers une zone mémoire non initialisée, définie par un début et un compte (objet fonction algorithme)
ranges::uninitialized_move (C++20)	déplace une plage d'objets vers une zone mémoire non initialisée (objet fonction algorithme)
ranges::uninitialized_move_n (C++20)	déplace un nombre d'objets vers une zone mémoire non initialisée (objet fonction algorithme)
ranges::uninitialized_default_construct (C++20)	construit des objets par initialisation par défaut dans une zone mémoire non initialisée, définie par une plage (objet fonction algorithme)
ranges::uninitialized_default_construct_n (C++20)	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 (objet fonction algorithme)
ranges::uninitialized_value_construct (C++20)	construit des objets par initialisation par valeur dans une zone mémoire non initialisée, définie par une plage (objet fonction algorithme)
ranges::uninitialized_value_construct_n (C++20)	construit des objets par initialisation par valeur dans une zone mémoire non initialisée, définie par un début et un compte (objet fonction algorithme)
ranges::construct_at (C++20)	crée un objet à une adresse donnée (objet fonction algorithme)
ranges::destroy_at (C++20)	détruit un objet à une adresse donnée (objet fonction algorithme)
ranges::destroy (C++20)	détruit une plage d'objets (objet fonction algorithme)
ranges::destroy_n (C++20)	détruit un nombre d'objets dans une plage (objet fonction algorithme)

Synopsis

#include <compare>
namespace std {
  // Traits de pointeur
  template<class Ptr>
  struct pointer_traits; // autonome
  template<class T>
  struct pointer_traits<T*>; // autonome
  // conversion de pointeur
  template<class T>
  constexpr T* to_address(T* p) noexcept; // autonome
  template<class Ptr>
  constexpr auto to_address(const Ptr& p) noexcept; // autonome
  // alignement des pointeurs
  void* align(size_t alignment, size_t size, void*& ptr, size_t& space); // autonome
  template<size_t N, class T>
  constexpr T* assume_aligned(T* ptr); // autonome
  template<size_t Alignment, class T>
  bool is_sufficiently_aligned(T* ptr);
  // gestion explicite de la durée de vie
  template<class T>
  T* start_lifetime_as(void* p) noexcept; // autonome
  template<class T>
  const T* start_lifetime_as(const void* p) noexcept; // autonome
  template<class T>
  volatile T* start_lifetime_as(volatile void* p) noexcept; // autonome
  template<class T>
  const volatile T* start_lifetime_as(const volatile void* p) noexcept; // autonome
  template<class T>
  T* start_lifetime_as_array(void* p, size_t n) noexcept; // autonome
  template<class T>
  const T* start_lifetime_as_array(const void* p, size_t n) noexcept; // autonome
  template<class T>
  volatile T* start_lifetime_as_array(volatile void* p,
                                      size_t n) noexcept; // autonome
  template<class T>
  const volatile T* start_lifetime_as_array(const volatile void* p, // autonome
                                            size_t n) noexcept;
  template<class T>
  T* trivially_relocate(T* first, T* last, T* result); // autonome
  template<class T>
  constexpr T* relocate(T* first, T* last, T* result); // autonome
  // argument d'allocateur
  struct allocator_arg_t
  {
    explicit allocator_arg_t() = default;
  };                                                // freestanding
  inline constexpr allocator_arg_t allocator_arg{}; // autonome
  // uses_allocator
  template<class T, class Alloc>
  struct uses_allocator; // autonome
  // uses_allocator
  template<class T, class Alloc>
  constexpr bool uses_allocator_v = uses_allocator<T, Alloc>::value; // autonome
  // construction avec uses-allocator
  template<class T, class Alloc, class... Args>
  constexpr auto uses_allocator_construction_args(const Alloc& alloc, // autonome
                                                  Args&&... args) noexcept;
  template<class T, class Alloc, class Tuple1, class Tuple2>
  constexpr auto uses_allocator_construction_args(const Alloc& alloc, // autonome
                                                  piecewise_construct_t,
                                                  Tuple1&& x,
                                                  Tuple2&& y) noexcept;
  template<class T, class Alloc>
  constexpr auto uses_allocator_construction_args(
    const Alloc& alloc) noexcept; // autonome
  template<class T, class Alloc, class U, class V>
  constexpr auto uses_allocator_construction_args(const Alloc& alloc, // autonome
                                                  U&& u,
                                                  V&& v) noexcept;
  template<class T, class Alloc, class U, class V>
  constexpr auto uses_allocator_construction_args(const Alloc& alloc, // autonome
                                                  pair<U, V>& pr) noexcept;
  template<class T, class Alloc, class U, class V>
  constexpr auto uses_allocator_construction_args(const Alloc& alloc, // autonome
                                                  const pair<U, V>& pr) noexcept;
  template<class T, class Alloc, class U, class V>
  constexpr auto uses_allocator_construction_args(const Alloc& alloc, // autonome
                                                  pair<U, V>&& pr) noexcept;
  template<class T, class Alloc, class U, class V>
  constexpr auto uses_allocator_construction_args(const Alloc& alloc, // autonome
                                                  const pair<U, V>&& pr) noexcept;
  template<class T, class Alloc, /*de type paire*/ P>
  constexpr auto uses_allocator_construction_args(const Alloc& alloc, // autonome
                                                  P&& p) noexcept;
  template<class T, class Alloc, class U>
  constexpr auto uses_allocator_construction_args(const Alloc& alloc, // autonome
                                                  U&& u) noexcept;
  template<class T, class Alloc, class... Args>
  constexpr T make_obj_using_allocator(const Alloc& alloc,
                                       Args&&... args); // autonome
  template<class T, class Alloc, class... Args>
  constexpr T* uninitialized_construct_using_allocator(T* p, // autonome
                                                       const Alloc& alloc,
                                                       Args&&... args);
  // allocator Traits
  template<class Alloc>
  struct allocator_traits; // autonome
  template<class Pointer, class SizeType = size_t>
  struct allocation_result
  { // autonome
    Pointer ptr;
    SizeType count;
  };
  // l'allocateur par défaut
  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; // autonome
  template<class T>
  const T* addressof(const T&&) = delete; // autonome
  // algorithmes spécialisés
  // concepts de mémoire spéciaux
  template<class I>
  concept no-throw-input-iterator = /* voir description */; // exposition uniquement
  template<class I>
  concept no-throw-forward-iterator = /* voir description */; // exposition uniquement
  template<class S, class I>
  concept no-throw-sentinel-for = /* voir description */; // exposition uniquement
  template<class R>
  concept no-throw-input-range = /* voir description */; // exposition uniquement
  template<class R>
  concept no-throw-forward-range = /* voir description */; // exposition uniquement
  template<class NoThrowForwardIter>
  constexpr void uninitialized_default_construct(NoThrowForwardIter first, // autonome
                                                 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); // autonome
  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); // autonome
    template<no-throw-forward-range R>
      requires default_initializable<range_value_t<R>>
    constexpr borrowed_iterator_t<R> uninitialized_default_construct(
      R&& r); // autonome
    template<no-throw-forward-iterator I>
      requires default_initializable<iter_value_t<I>>
    constexpr I uninitialized_default_construct_n(I first, // autonome
                                                  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); // autonome
  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); // autonome
    template<no-throw-forward-range R>
      requires default_initializable<range_value_t<R>>
    constexpr borrowed_iterator_t<R> uninitialized_value_construct(R&& r); // autonome
    template<no-throw-forward-iterator I>
      requires default_initializable<iter_value_t<I>>
    constexpr I uninitialized_value_construct_n(I first, // autonome
                                                iter_difference_t<I> n);
  }
  template<class InputIter, class NoThrowForwardIter>
  constexpr NoThrowForwardIter uninitialized_copy(InputIter first, // autonome
                                                  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, // autonome
                                                    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>; // autonome
    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); // autonome
    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); // autonome
    template<class I, class O>
    using uninitialized_copy_n_result = in_out_result<I, O>; // autonome
    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, // autonome
      O ofirst,
      S olast);
  }
  template<class InputIter, class NoThrowForwardIter>
  constexpr NoThrowForwardIter uninitialized_move(InputIter first, // autonome
                                                  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, // autonome
    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>; // autonome
    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); // autonome
    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); // autonome
    template<class I, class O>
    using uninitialized_move_n_result = in_out_result<I, O>; // autonome
    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, // autonome
      O ofirst,
      S olast);
  }
  template<class NoThrowForwardIter, class T>
  constexpr void uninitialized_fill(NoThrowForwardIter first, // autonome
                                    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); // autonome
  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); // autonome
    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); // autonome
    template<no-throw-forward-iterator I, class T>
      requires constructible_from<iter_value_t<I>, const T&>
    constexpr I uninitialized_fill_n(I first, // autonome
                                     iter_difference_t<I> n,
                                     const T& x);
  }
  // construct_at
  template<class T, class... Args>
  constexpr T* construct_at(T* location, Args&&... args); // autonome
  namespace ranges {
    template<class T, class... Args>
    constexpr T* construct_at(T* location, Args&&... args); // autonome
  }
  // détruire
  template<class T>
  constexpr void destroy_at(T* location); // autonome
  template<class NoThrowForwardIter>
  constexpr void destroy(NoThrowForwardIter first, // autonome
                         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, // autonome
                                         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; // autonome
    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; // autonome
    template<no-throw-input-range R>
      requires destructible<range_value_t<R>>
    constexpr borrowed_iterator_t<R> destroy(R&& r) noexcept; // autonome
    template<no-throw-input-iterator I>
      requires destructible<iter_value_t<I>>
    constexpr I destroy_n(I first, iter_difference_t<I> n) noexcept; // autonome
  }
  // modèle de classe unique_ptr
  template<class T>
  struct default_delete; // autonome
  template<class T>
  struct default_delete<T[]>; // autonome
  template<class T, class D = default_delete<T>>
  class unique_ptr; // autonome
  template<class T, class D>
  class unique_ptr<T[], D>; // autonome
  template<class T, class... Args>
  constexpr unique_ptr<T> make_unique(Args&&... args); // T n'est pas un tableau
  template<class T>
  constexpr unique_ptr<T> make_unique(size_t n); // T est U[]
  template<class T, class... Args>
  /* non spécifié */ make_unique(Args&&...) = delete; // T est U[N]
  template<class T>
  constexpr unique_ptr<T> make_unique_for_overwrite(); // T n'est pas un tableau
  template<class T>
  constexpr unique_ptr<T> make_unique_for_overwrite(size_t n); // T est U[]
  template<class T, class... Args>
  /* non spécifié */ make_unique_for_overwrite(Args&&...) = delete; // T est U[N]
  template<class T, class D>
  constexpr void swap(unique_ptr<T, D>& x, unique_ptr<T, D>& y) noexcept; // autonome
  template<class T1, class D1, class T2, class D2>
  constexpr bool operator==(const unique_ptr<T1, D1>& x, // autonome
                            const unique_ptr<T2, D2>& y);
  template<class T1, class D1, class T2, class D2>
  bool operator<(const unique_ptr<T1, D1>& x,
                 const unique_ptr<T2, D2>& y); // autonome
  template<class T1, class D1, class T2, class D2>
  bool operator>(const unique_ptr<T1, D1>& x,
                 const unique_ptr<T2, D2>& y); // autonome
  template<class T1, class D1, class T2, class D2>
  bool operator<=(const unique_ptr<T1, D1>& x,
                  const unique_ptr<T2, D2>& y); // autonome
  template<class T1, class D1, class T2, class D2>
  bool operator>=(const unique_ptr<T1, D1>& x,
                  const unique_ptr<T2, D2>& y); // autonome
  template<class T1, class D1, class T2, class D2>
    requires three_way_comparable_with<typename unique_ptr<T1, D1>::pointeur,
                                       typename unique_ptr<T2, D2>::pointeur>
  compare_three_way_result_t<typename unique_ptr<T1, D1>::pointeur,
                             typename unique_ptr<T2, D2>::pointeur>
  operator<=>(const unique_ptr<T1, D1>& x, const unique_ptr<T2, D2>& y); // autonome
  template<class T, class D>
  constexpr bool operator==(const unique_ptr<T, D>& x,
                            nullptr_t) noexcept; // autonome
  template<class T, class D>
  constexpr bool operator<(const unique_ptr<T, D>& x, nullptr_t); // autonome
  template<class T, class D>
  constexpr bool operator<(nullptr_t, const unique_ptr<T, D>& y); // autonome
  template<class T, class D>
  constexpr bool operator>(const unique_ptr<T, D>& x, nullptr_t); // autonome
  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); // autonome
  template<class T, class D>
  constexpr bool operator<=(nullptr_t, const unique_ptr<T, D>& y); // autonome
  template<class T, class D>
  constexpr bool operator>=(const unique_ptr<T, D>& x, nullptr_t); // autonome
  template<class T, class D>
  constexpr bool operator>=(nullptr_t, const unique_ptr<T, D>& y); // autonome
  template<class T, class D>
    requires three_way_comparable<typename unique_ptr<T, D>::pointeur>
  constexpr compare_three_way_result_t<typename unique_ptr<T, D>::pointeur> operator<=>(
    const unique_ptr<T, D>& x,
    nullptr_t); // autonome
  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);
  // classe bad_weak_ptr
  class bad_weak_ptr;
  // modèle de classe shared_ptr
  template<class T>
  class shared_ptr;
  // création de shared_ptr
  template<class T, class... Args>
  shared_ptr<T> make_shared(Args&&... args); // T n'est pas un tableau
  template<class T, class A, class... Args>
  shared_ptr<T> allocate_shared(const A& a, Args&&... args); // T n'est pas un tableau
  template<class T>
  shared_ptr<T> make_shared(size_t N); // T est U[]
  template<class T, class A>
  shared_ptr<T> allocate_shared(const A& a, size_t N); // T est U[]
  template<class T>
  shared_ptr<T> make_shared(); // T est U[N]
  template<class T, class A>
  shared_ptr<T> allocate_shared(const A& a); // T est U[N]
  template<class T>
  shared_ptr<T> make_shared(size_t N, const remove_extent_t<T>& u); // T est U[]
  template<class T, class A>
  shared_ptr<T> allocate_shared(const A& a,
                                size_t N,
                                const remove_extent_t<T>& u); // T est U[]
  template<class T>
  shared_ptr<T> make_shared(const remove_extent_t<T>& u); // T est U[N]
  template<class T, class A>
  shared_ptr<T> allocate_shared(const A& a, const remove_extent_t<T>& u); // T est U[N]
  template<class T>
  shared_ptr<T> make_shared_for_overwrite(); // T n'est pas U[]
  template<class T, class A>
  shared_ptr<T> allocate_shared_for_overwrite(const A& a); // T n'est pas U[]
  template<class T>
  shared_ptr<T> make_shared_for_overwrite(size_t N); // T est U[]
  template<class T, class A>
  shared_ptr<T> allocate_shared_for_overwrite(const A& a, size_t N); // T est U[]
  // comparaisons de shared_ptr
  template<class T, class U>
  bool operator==(const shared_ptr<T>& a, const shared_ptr<U>& b) noexcept;
  template<class T, class U>
  strong_ordering operator<=>(const shared_ptr<T>& a, const shared_ptr<U>& b) noexcept;
  template<class T>
  bool operator==(const shared_ptr<T>& x, nullptr_t) noexcept;
  template<class T>
  strong_ordering operator<=>(const shared_ptr<T>& x, nullptr_t) noexcept;
  // Algorithmes spécialisés pour shared_ptr
  template<class T>
  void swap(shared_ptr<T>& a, shared_ptr<T>& b) noexcept;
  // casts de shared_ptr
  template<class T, class U>
  shared_ptr<T> static_pointer_cast(const shared_ptr<U>& r) noexcept;
  template<class T, class U>
  shared_ptr<T> static_pointer_cast(shared_ptr<U>&& r) noexcept;
  template<class T, class U>
  shared_ptr<T> dynamic_pointer_cast(const shared_ptr<U>& r) noexcept;
  template<class T, class U>
  shared_ptr<T> dynamic_pointer_cast(shared_ptr<U>&& r) noexcept;
  template<class T, class U>
  shared_ptr<T> const_pointer_cast(const shared_ptr<U>& r) noexcept;
  template<class T, class U>
  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>
  D* get_deleter(const shared_ptr<T>& p) noexcept;
  // E/S de shared_ptr
  template<class E, class T, class Y>
  basic_ostream<E, T>& operator<<(basic_ostream<E, T>& os, const shared_ptr<Y>& p);
  // modèle de classe weak_ptr
  template<class T>
  class weak_ptr;
  // Algorithmes spécialisés pour weak_ptr
  template<class T>
  void swap(weak_ptr<T>& a, weak_ptr<T>& b) noexcept;
  // modèle de classe 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;
  // prise en charge du hachage
  template<class T>
  struct hash; // autonome
  template<class T, class D>
  struct hash<unique_ptr<T, D>>; // autonome
  template<class T>
  struct hash<shared_ptr<T>>;
  // pointeurs intelligents atomiques
  template<class T>
  struct atomic; // autonome
  template<class T>
  struct atomic<shared_ptr<T>>;
  template<class T>
  struct atomic<weak_ptr<T>>;
  // modèle de classe out_ptr_t
  template<class Smart, class Pointer, class... Args>
  class out_ptr_t; // autonome
  // modèle de fonction out_ptr
  template<class Pointer = void, class Smart, class... Args>
  auto out_ptr(Smart& s, Args&&... args); // autonome
  // modèle de classe inout_ptr_t
  template<class Smart, class Pointer, class... Args>
  class inout_ptr_t; // freestanding
  // modèle de fonction inout_ptr
  template<class Pointer = void, class Smart, class... Args>
  auto inout_ptr(Smart& s, Args&&... args); // autonome
  // modèle de classe indirect
  template<class T, class Allocator = allocator<T>>
  class indirect;
  // support de hachage
  template<class T, class Alloc>
  struct hash<indirect<T, Alloc>>;
  // modèle de classe polymorphique
  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>>;
  }
}

Concepts d'assistance

Note : Ces noms sont uniquement à titre d'exposition, ils ne font pas partie de l'interface.

template<class I>
concept no-throw-input-iterator = // uniquement pour exposition
  input_iterator<I> &&
  is_lvalue_reference_v<iter_reference_t<I>> &&
  same_as<remove_cvref_t<iter_reference_t<I>>, iter_value_t<I>>;
template<class S, class I>
concept no-throw-sentinel-for = sentinel_for<S, I>; // uniquement pour exposition
template<class R>
concept no-throw-input-range = // uniquement pour exposition
  ranges::range<R> &&
  no-throw-input-iterator<ranges::iterator_t<R>> &&
  no-throw-sentinel-for<ranges::sentinel_t<R>, ranges::iterator_t<R>>;
template<class I>
concept no-throw-forward-iterator = // uniquement pour exposition
  no-throw-input-iterator<I> &&
  forward_iterator<I> &&
  no-throw-sentinel-for<I, I>;
template<class R>
concept no-throw-forward-range = // uniquement pour exposition
  no-throw-input-range<R> &&
  no-throw-forward-iterator<ranges::iterator_t<R>>;

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

cppreference.net

Namespaces

Variants

Standard library header <memory>

Table des matières

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

Construction avec allocateur

Divers

Gestion explicite de la durée de vie

Prise en charge du ramasse-miettes

Stockage non initialisé

Opérations non membres sur les pointeurs intelligents

Création d'adaptateur de pointeur intelligent

Entités de type fonction

Stockage non initialisé

Synopsis

Concepts d'assistance

Modèle de classe std::pointer_traits

Classe std::allocator_arg_t

Modèle de classe std::allocator_traits

Modèle de classe std::allocator

Modèle de classe std::default_delete

Modèle de classe std::unique_ptr

Classe std::bad_weak_ptr

Modèle de classe std::shared_ptr

Modèle de classe std::weak_ptr

Modèle de classe std::owner_less

Classe std::owner_hash

Classe std::owner_equal

Modèle de classe std::enable_shared_from_this

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

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

Modèle de classe std:: out_ptr_t

Modèle de classe std:: inout_ptr_t

Modèle de classe std :: indirect

Modèle de classe std :: polymorphic