Standard library header <memory>

From es.cppreference.net

Este encabezado es parte de la biblioteca de gestión de memoria dinámica .

Contenido 1 Inclusiones 2 Clases 2.1 Rasgos de puntero 2.2 Soporte de recolector de basura 2.3 Asignadores 2.4 Almacenamiento no inicializado 2.5 Punteros inteligentes 2.6 Adaptadores de punteros inteligentes 2.7 Tipos para diseño de clases compuestas 2.8 Clases auxiliares 2.9 Declaraciones adelantadas 3 Etiquetas 4 Funciones / Entidades similares a funciones 4.1 Construcción con uso de asignador 4.2 Varios 4.3 Gestión explícita del tiempo de vida 4.4 Soporte de recolector de basura 4.5 Especializados <memory> algoritmos 4.6 Operaciones no miembro de punteros inteligentes 4.7 Creación de adaptadores de punteros inteligentes 5 Sinopsis 5.1 Plantilla de clase std::pointer_traits 5.2 Clase std::allocator_arg_t 5.3 Plantilla de clase std::allocator_traits 5.4 Plantilla de clase std::allocator 5.5 Plantilla de clase std::default_delete 5.6 Plantilla de clase std::unique_ptr 5.7 Clase std::bad_weak_ptr 5.8 Plantilla de clase std::shared_ptr 5.9 Plantilla de clase std::weak_ptr 5.10 Plantilla de clase std::owner_less 5.11 Clase std::owner_hash 5.12 Clase std::owner_equal 5.13 Plantilla de clase std::enable_shared_from_this 5.14 Plantilla de clase std::atomic especialización para std::shared_ptr 5.15 Plantilla de clase std::atomic especialización para std::weak_ptr 5.16 Plantilla de clase std::out_ptr_t 5.17 Plantilla de clase std::inout_ptr_t 5.18 Plantilla de clase std::indirect 5.19 Plantilla de clase std::polymorphic Incluye
<compare> (C++20)	Soporte para operador de comparación de tres vías
Clases
Rasgos de puntero
pointer_traits (C++11)	proporciona información sobre tipos similares a punteros (plantilla de clase)
Soporte para recolector de basura
pointer_safety (C++11) (removed in C++23)	enumera los modelos de seguridad de punteros (enum)
Asignadores
allocator	el asignador predeterminado (plantilla de clase)
allocator_traits (C++11)	proporciona información sobre tipos de allocator (plantilla de clase)
allocation_result (C++23)	registra la dirección y el tamaño real del almacenamiento asignado por `allocate_at_least` (plantilla de clase)
uses_allocator (C++11)	verifica si el tipo especificado admite la construcción uses-allocator (plantilla de clase)
Almacenamiento no inicializado
raw_storage_iterator (obsoleto en C++17) (eliminado en C++20)	un iterador que permite a los algoritmos estándar almacenar resultados en memoria no inicializada (plantilla de clase)
Punteros inteligentes
unique_ptr (C++11)	puntero inteligente con semántica de propiedad única de objetos (plantilla de clase)
shared_ptr (C++11)	puntero inteligente con semántica de propiedad compartida de objetos (plantilla de clase)
weak_ptr (C++11)	referencia débil a un objeto gestionado por std::shared_ptr (plantilla de clase)
auto_ptr (deprecated in C++11) (removed in C++17)	puntero inteligente con semántica de propiedad de objeto estricta (plantilla de clase)
Adaptadores de punteros inteligentes
out_ptr_t (C++23)	interopera con establecedores de punteros externos y restablece un puntero inteligente en la destrucción (plantilla de clase)
inout_ptr_t (C++23)	interopera con establecedores de punteros externos, obtiene el valor inicial del puntero desde un puntero inteligente y lo restablece en la destrucción (plantilla de clase)
Tipos para diseño de clases compuestas
indirect (C++26)	un contenedor que contiene un objeto asignado dinámicamente con semántica de valor (plantilla de clase)
polymorphic (C++26)	un contenedor polimórfico que contiene un objeto asignado dinámicamente con semántica de valor (plantilla de clase)
Clases auxiliares
std::atomic <std::shared_ptr> (C++20)	puntero compartido atómico (especialización de plantilla de clase)
std::atomic <std::weak_ptr> (C++20)	puntero débil atómico (especialización de plantilla de clase)
owner_less (C++11)	proporciona ordenación basada en propietario de tipos mixtos para punteros shared y weak (plantilla de clase)
owner_hash (C++26)	proporciona hashing basado en propietario para punteros compartidos y débiles (clase)
owner_equal (C++26)	proporciona comparaciones de igualdad basadas en propietario de tipos mixtos para punteros shared y weak (clase)
enable_shared_from_this (C++11)	permite que un objeto cree un `shared_ptr` que haga referencia a sí mismo (plantilla de clase)
bad_weak_ptr (C++11)	excepción lanzada al acceder a un `weak_ptr` que referencia un objeto ya destruido (clase)
default_delete (C++11)	eliminador predeterminado para unique_ptr (plantilla de clase)
std::hash <std::unique_ptr> (C++11)	soporte de hash para `std::unique_ptr` (especialización de plantilla de clase)
std::hash <std::shared_ptr> (C++11)	soporte de hash para `std::shared_ptr` (especialización de plantilla de clase)
std::hash <std::indirect> (C++26)	soporte de hash para `std::indirect` (especialización de plantilla de clase)
Declaraciones anticipadas
Definido en el encabezado `<functional>`
hash (C++11)	objeto función hash (plantilla de clase)
Definido en el encabezado `<atomic>`
atomic (C++11)	plantilla de clase atomic y especializaciones para bool, integral, tipos de coma flotante, (desde C++20) y tipos de puntero (plantilla de clase)
Etiquetas
allocator_arg allocator_arg_t (C++11)	una etiqueta utilizada para seleccionar constructores conscientes del asignador (etiqueta)
Funciones / Entidades similares a funciones
Construcción con asignador de memoria
uses_allocator_construction_args (C++20)	prepara la lista de argumentos que coincide con el tipo de construcción uses-allocator requerido por el tipo dado (plantilla de función)
make_obj_using_allocator (C++20)	crea un objeto del tipo dado mediante construcción uses-allocator (plantilla de función)
uninitialized_construct_using_allocator (C++20)	crea un objeto del tipo dado en la ubicación de memoria especificada mediante construcción uses-allocator (plantilla de función)
Misceláneos
to_address (C++20)	obtiene un puntero sin procesar a partir de un tipo similar a puntero (plantilla de función)
addressof (C++11)	obtiene la dirección real de un objeto, incluso si el operador `&` está sobrecargado (plantilla de función)
align (C++11)	alinea un puntero en un búfer (función)
assume_aligned (C++20)	informa al compilador que un puntero está alineado (plantilla de función)
is_sufficiently_aligned (C++26)	verifica si el puntero apunta a un objeto cuya alineación tiene al menos el valor dado (plantilla de función)
Gestión explícita del tiempo de vida
start_lifetime_as start_lifetime_as_array (C++23)	crea implícitamente objetos en el almacenamiento dado reutilizando la representación del objeto (plantilla de función)
Soporte para recolector de basura
declare_reachable (C++11) (eliminado en C++23)	declara que un objeto no puede ser reciclado (función)
undeclare_reachable (C++11) (eliminado en C++23)	declara que un objeto puede ser reciclado (plantilla de función)
declare_no_pointers (C++11) (eliminado en C++23)	declara que un área de memoria no contiene punteros rastreables (función)
undeclare_no_pointers (C++11) (eliminado en C++23)	cancela el efecto de std::declare_no_pointers (función)
get_pointer_safety (C++11) (eliminado en C++23)	devuelve el modelo actual de seguridad de punteros (función)
Especializados `<memory>` algoritmos
uninitialized_copy	copia un rango de objetos a un área de memoria no inicializada (plantilla de función & objeto función de algoritmo)
ranges::uninitialized_copy (C++20)
uninitialized_copy_n (C++11)	copia un número de objetos a un área de memoria no inicializada (plantilla de función & objeto función de algoritmo)
ranges::uninitialized_copy_n (C++20)
uninitialized_fill	copia un objeto a un área de memoria no inicializada, definida por un rango (plantilla de función & objeto función de algoritmo)
ranges::uninitialized_fill (C++20)
uninitialized_fill_n	copia un objeto a un área de memoria no inicializada, definida por un inicio y un recuento (plantilla de función & objeto función de algoritmo)
ranges::uninitialized_fill_n (C++20)
uninitialized_move (C++17)	mueve un rango de objetos a un área de memoria no inicializada (plantilla de función & objeto función de algoritmo)
ranges::uninitialized_move (C++20)
uninitialized_move_n (C++17)	mueve un número de objetos a un área de memoria no inicializada (plantilla de función & objeto función de algoritmo)
ranges::uninitialized_move_n (C++20)
uninitialized_default_construct (C++17)	construye objetos mediante inicialización por defecto en un área de memoria no inicializada, definida por un rango (plantilla de función & objeto función de algoritmo)
ranges::uninitialized_default_construct (C++20)
uninitialized_default_construct_n (C++17)	construye objetos mediante inicialización por defecto en un área de memoria no inicializada, definida por un inicio y un recuento (plantilla de función & objeto función de algoritmo)
ranges::uninitialized_default_construct_n (C++20)
uninitialized_value_construct (C++17)	construye objetos mediante inicialización por valor en un área de memoria no inicializada, definida por un rango (plantilla de función & objeto función de algoritmo)
ranges::uninitialized_value_construct (C++20)
uninitialized_value_construct_n (C++17)	construye objetos mediante inicialización por valor en un área de memoria no inicializada, definida por un inicio y un recuento (plantilla de función & objeto función de algoritmo)
ranges::uninitialized_value_construct_n (C++20)
construct_at (C++20)	crea un objeto en una dirección dada (plantilla de función & objeto función de algoritmo)
ranges::construct_at (C++20)
destroy_at (C++17)	destruye un objeto en una dirección dada (plantilla de función & objeto función de algoritmo)
ranges::destroy_at (C++20)
destroy (C++17)	destruye un rango de objetos (plantilla de función & objeto función de algoritmo)
ranges::destroy (C++20)
destroy_n (C++17)	destruye un número de objetos en un rango (plantilla de función & objeto función de algoritmo)
ranges::destroy_n (C++20)
get_temporary_buffer (obsoleto en C++17)(eliminado en C++20)	obtiene almacenamiento no inicializado (plantilla de función)
return_temporary_buffer (obsoleto en C++17)(eliminado en C++20)	libera almacenamiento no inicializado (plantilla de función)
Operaciones no miembro de punteros inteligentes
make_unique make_unique_for_overwrite (C++14) (C++20)	crea un puntero único que gestiona un nuevo objeto (plantilla de función)
operator== operator!= operator< operator<= operator> operator>= operator<=> (eliminado en C++20) (C++20)	compara con otro `unique_ptr` o con nullptr (plantilla de función)
make_shared make_shared_for_overwrite (C++20)	crea un puntero compartido que gestiona un nuevo objeto (plantilla de función)
allocate_shared allocate_shared_for_overwrite (C++20)	crea un puntero compartido que gestiona un nuevo objeto asignado usando un asignador (plantilla de función)
static_pointer_cast dynamic_pointer_cast const_pointer_cast reinterpret_pointer_cast (C++17)	aplica `static_cast` , `dynamic_cast` , `const_cast` , o `reinterpret_cast` al puntero almacenado (plantilla de función)
get_deleter	devuelve el deleter del tipo especificado, si está poseído (plantilla de función)
operator== operator!= operator< operator<= operator> operator>= operator<=> (eliminado en C++20) (eliminado en C++20) (eliminado en C++20) (eliminado en C++20) (eliminado en C++20) (C++20)	compara con otro `shared_ptr` o con nullptr (plantilla de función)
operator<< (std::shared_ptr)	envía el valor del puntero almacenado a un flujo de salida (plantilla de función)
operator<< (std::unique_ptr) (C++20)	envía el valor del puntero administrado a un flujo de salida (plantilla de función)
std::swap (std::unique_ptr) (C++11)	especializa el algoritmo std::swap (plantilla de función)
std::swap (std::shared_ptr) (C++11)	especializa el algoritmo std::swap (plantilla de función)
std::swap (std::weak_ptr) (C++11)	especializa el algoritmo std::swap (plantilla de función)
Creación de adaptadores de puntero inteligente
out_ptr (C++23)	crea un `out_ptr_t` con un puntero inteligente asociado y argumentos de restablecimiento (plantilla de función)
inout_ptr (C++23)	crea un `inout_ptr_t` con un puntero inteligente asociado y argumentos de restablecimiento (plantilla de función)

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)

(obsoleto en C++20)(eliminado en C++26)

especializa operaciones atómicas para std::shared_ptr
(plantilla de función)

Sinopsis

#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>>;
  }
}

Plantilla de clase std::pointer_traits

namespace std {
  template<class Ptr>
  struct pointer_traits
  {
    /* ver descripción */;
  };
  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(/* ver descripción */ r) noexcept;
  };
}

Clase std::allocator_arg_t

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

Plantilla de clase std::allocator_traits

namespace std {
  template<class Alloc>
  struct allocator_traits
  {
    using allocator_type                         = Alloc;
    using value_type                             = typename Alloc::value_type;
    using pointer                                = /* ver descripción */;
    using const_pointer                          = /* ver descripción */;
    using void_pointer                           = /* ver descripción */;
    using const_void_pointer                     = /* ver descripción */;
    using difference_type                        = /* ver descripción */;
    using size_type                              = /* ver descripción */;
    using propagate_on_container_copy_assignment = /* ver descripción */;
    using propagate_on_container_move_assignment = /* ver descripción */;
    using propagate_on_container_swap            = /* ver descripción */;
    using is_always_equal                        = /* ver descripción */;
    template<class T>
    using rebind_alloc = /* ver descripción */;
    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);
  };
}

Plantilla de clase 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);
  };
}

Plantilla de clase 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;
  };
}

Plantilla de clase std::unique_ptr

namespace std {
  template<class T, class D = default_delete<T>>
  class unique_ptr
  {
  public:
    using pointer      = /* ver descripción */;
    using element_type = T;
    using deleter_type = D;
    // constructores
    constexpr unique_ptr() noexcept;
    constexpr explicit unique_ptr(type_identity_t<pointer> p) noexcept;
    constexpr unique_ptr(type_identity_t<pointer> p, /* ver descripción */ d1) noexcept;
    constexpr unique_ptr(type_identity_t<pointer> p, /* ver descripción */ 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;
    // destructor
    constexpr ~unique_ptr();
    // asignación
    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;
    // observadores
    constexpr add_lvalue_reference_t<T> operator*() const noexcept(/* ver descripción */);
    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;
    // modificadores
    constexpr pointer release() noexcept;
    constexpr void reset(pointer p = pointer()) noexcept;
    constexpr void swap(unique_ptr& u) noexcept;
    // deshabilitar copia desde 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      = /* ver descripción */;
    using element_type = T;
    using deleter_type = D;
    // constructores
    constexpr unique_ptr() noexcept;
    template<class U>
    constexpr explicit unique_ptr(U p) noexcept;
    template<class U>
    constexpr unique_ptr(U p, /* ver descripción */ d) noexcept;
    template<class U>
    constexpr unique_ptr(U p, /* ver descripción */ 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;
    // destructor
    constexpr ~unique_ptr();
    // asignación
    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;
    // observadores
    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;
    // modificadores
    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;
    // deshabilitar copia desde lvalue
    unique_ptr(const unique_ptr&)            = delete;
    unique_ptr& operator=(const unique_ptr&) = delete;
  };
}

Clase std::bad_weak_ptr

namespace std {
  class bad_weak_ptr : public exception
  {
  public:
    // para la especificación de las funciones miembro especiales
    const char* what() const noexcept override;
  };
}

Plantilla de clase 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>;
    // constructores
    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);
    // destructor
    ~shared_ptr();
    // asignación
    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);
    // modificadores
    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);
    // observadores
    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>;
}

Plantilla de clase std::weak_ptr

namespace std {
  template<class T>
  class weak_ptr
  {
  public:
    using element_type = remove_extent_t<T>;
    // constructores
    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;
    // destructor
    ~weak_ptr();
    // asignación
    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;
    // modificadores
    void swap(weak_ptr& r) noexcept;
    void reset() noexcept;
    // observadores
    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>;
}

Plantilla de clase 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 = /* no especificado */;
  };
}

Clase 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 = /* no especificado */;
  };
}

Clase 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 = /* no especificado */;
  };
}

Plantilla de clase 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*/; // solo para exposición
  };
}

Especialización de la plantilla de clase std::atomic para 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 = /* definido por la implementación */;
    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;            // solo para exposición
  };
}

Especialización de la plantilla de clase std::atomic para 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 = /* definido por la implementación */;
    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;              // solo para exposición
  };
}

Plantilla de clase 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;         // solo para exposición
    tuple<Args...> a; // solo para exposición
    Pointer p;        // solo para exposición
  };
}

Plantilla de clase 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;         // solo para exposición
    tuple<Args...> a; // solo para exposición
    Pointer p;        // solo para exposición
  };
}

Plantilla de clase 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;
    // constructores
    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(/* ver descripción */);
    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... Nosotros>
    constexpr explicit indirect(in_place_t, Us&&... us);
    template<class... Nosotros>
    constexpr explicit indirect(allocator_arg_t,
                                const Allocator& a,
                                in_place_t,
                                Us&&... us);
    template<class I, class... Nosotros>
    constexpr explicit indirect(in_place_t, initializer_list<I> ilist, Us&&... us);
    template<class I, class... Nosotros>
    constexpr explicit indirect(allocator_arg_t,
                                const Allocator& a,
                                in_place_t,
                                initializer_list<I> ilist,
                                Us&&... us);
    // destructor
    constexpr ~indirect();
    // asignación
    constexpr indirect& operator=(const indirect& other);
    constexpr indirect& operator=(indirect&& other) noexcept(/* ver descripción */);
    template<class U = T>
    constexpr indirect& operator=(U&& u);
    // observadores
    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;
    // swap
    constexpr void swap(indirect& other) noexcept(/* ver descripción */);
    friend constexpr void swap(indirect& lhs,
                               indirect& rhs) noexcept(/* ver descripción */);
    // operadores relacionales
    template<class U, class AA>
    friend constexpr bool operator==(
      const indirect& lhs,
      const indirect<U, AA>& rhs) noexcept(/* ver descripción */);
    template<class U, class AA>
    friend constexpr auto operator<=>(const indirect& lhs, const indirect<U, AA>& rhs)
      -> /*synth-three-way-result*/<T, U>;
    // comparación con T
    template<class U>
    friend constexpr bool operator==(const indirect& lhs,
                                     const U& rhs) noexcept(/* ver descripción */);
    template<class U>
    friend constexpr auto operator<=>(const indirect& lhs, const U& rhs)
      -> /*synth-three-way-result*/<T, U>;
  private:
    pointer /*p*/;                     // exposición-solamente
    Allocator /*alloc*/ = Allocator(); // exposición-solamente
  };
  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>>;
}

Plantilla de clase 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;
    // constructores
    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(/* ver descripción */);
    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);
    // destructor
    constexpr ~polymorphic();
    // asignación
    constexpr polymorphic& operator=(const polymorphic& other);
    constexpr polymorphic& operator=(polymorphic&& other) noexcept(/* ver descripción */);
    // observadores
    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;
    // intercambio
    constexpr void swap(polymorphic& other) noexcept(/* ver descripción */);
    friend constexpr void swap(polymorphic& lhs,
                               polymorphic& rhs) noexcept(/* ver descripción */);
  private:
    Allocator /*alloc*/ = Allocator(); // solo para exposición
  };
}

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

es.cppreference.net

Namespaces

Variants

Standard library header <memory>

Contenido

Incluye

Clases

Rasgos de puntero

Soporte para recolector de basura

Asignadores

Almacenamiento no inicializado

Punteros inteligentes

Adaptadores de punteros inteligentes

Tipos para diseño de clases compuestas

Clases auxiliares

Declaraciones anticipadas

Etiquetas

Funciones / Entidades similares a funciones

Construcción con asignador de memoria

Misceláneos

Gestión explícita del tiempo de vida

Soporte para recolector de basura

Especializados <memory> algoritmos

Operaciones no miembro de punteros inteligentes

Creación de adaptadores de puntero inteligente

Sinopsis

Plantilla de clase std::pointer_traits

Clase std::allocator_arg_t

Plantilla de clase std::allocator_traits

Plantilla de clase std::allocator

Plantilla de clase std::default_delete

Plantilla de clase std::unique_ptr

Clase std::bad_weak_ptr

Plantilla de clase std::shared_ptr

Plantilla de clase std::weak_ptr

Plantilla de clase std::owner_less

Clase std::owner_hash

Clase std::owner_equal

Plantilla de clase std::enable_shared_from_this

Especialización de la plantilla de clase std::atomic para std::shared_ptr

Especialización de la plantilla de clase std::atomic para std::weak_ptr

Plantilla de clase std:: out_ptr_t

Plantilla de clase std:: inout_ptr_t

Plantilla de clase std :: indirect

Plantilla de clase std :: polymorphic

Especializados `<memory>` algoritmos