Standard library header <memory>

From cppreference.net

< cpp ‎ | header

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

Contenidos

Incluye

(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

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)

Almacenamiento no inicializado

uninitialized_copy

copia un rango de objetos a un área de memoria no inicializada
(plantilla de función)

uninitialized_copy_n

(C++11)

copia un número de objetos a un área de memoria no inicializada
(plantilla de función)

uninitialized_fill

copia un objeto a un área de memoria no inicializada, definida por un rango
(plantilla de función)

uninitialized_fill_n

copia un objeto a un área de memoria no inicializada, definida por un inicio y un contador
(plantilla de función)

uninitialized_move

(C++17)

mueve un rango de objetos a un área de memoria no inicializada
(plantilla de función)

uninitialized_move_n

(C++17)

mueve una cantidad de objetos a un área de memoria no inicializada
(plantilla de función)

uninitialized_default_construct

(C++17)

construye objetos mediante default-initialization en un área de memoria no inicializada, definida por un rango
(plantilla de función)

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 contador
(plantilla de función)

uninitialized_value_construct

(C++17)

construye objetos mediante value-initialization en un área de memoria no inicializada, definida por un rango
(plantilla de función)

uninitialized_value_construct_n

(C++17)

construye objetos mediante value-initialization en un área de memoria no inicializada, definida por un inicio y un conteo
(plantilla de función)

construct_at

(C++20)

crea un objeto en una dirección dada
(plantilla de función)

destroy_at

(C++17)

destruye un objeto en una dirección dada
(plantilla de función)

destroy

(C++17)

destruye un rango de objetos
(plantilla de función)

destroy_n

(C++17)

destruye una cantidad de objetos en un rango
(plantilla de función)

get_temporary_buffer

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

obtiene almacenamiento no inicializado
(plantilla de función)

return_temporary_buffer

(deprecated in C++17) (removed in C++20)

libera almacenamiento no inicializado
(function template)

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 adaptador de puntero inteligente

out_ptr

(C++23)

crea un


          out_ptr_t

con un puntero inteligente asociado y argumentos de reinicio
(plantilla de función)

inout_ptr

(C++23)

crea un


          inout_ptr_t

con un puntero inteligente asociado y argumentos de reinicio
(plantilla de función)

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

especializa operaciones atómicas para


          std::shared_ptr

(plantilla de función)

Entidades similares a funciones
Definido en el espacio de nombres `std::ranges`
Almacenamiento no inicializado
ranges::uninitialized_copy (C++20)	copia un rango de objetos a un área de memoria no inicializada (objeto función de algoritmo)
ranges::uninitialized_copy_n (C++20)	copia un número de objetos a un área de memoria no inicializada (objeto función de algoritmo)
ranges::uninitialized_fill (C++20)	copia un objeto a un área de memoria no inicializada, definida por un rango (objeto función de algoritmo)
ranges::uninitialized_fill_n (C++20)	copia un objeto a un área de memoria no inicializada, definida por un inicio y un contador (objeto función de algoritmo)
ranges::uninitialized_move (C++20)	mueve un rango de objetos a un área de memoria no inicializada (objeto función de algoritmo)
ranges::uninitialized_move_n (C++20)	mueve un número de objetos a un área de memoria no inicializada (objeto función de algoritmo)
ranges::uninitialized_default_construct (C++20)	construye objetos mediante inicialización por defecto en un área de memoria no inicializada, definida por un rango (objeto función de algoritmo)
ranges::uninitialized_default_construct_n (C++20)	construye objetos mediante inicialización por defecto en un área de memoria no inicializada, definida por un inicio y contador (objeto función de algoritmo)
ranges::uninitialized_value_construct (C++20)	construye objetos mediante inicialización por valor en un área de memoria no inicializada, definida por un rango (objeto función de algoritmo)
ranges::uninitialized_value_construct_n (C++20)	construye objetos mediante inicialización por valor en un área de memoria no inicializada, definida por un inicio y un contador (objeto función de algoritmo)
ranges::construct_at (C++20)	crea un objeto en una dirección dada (objeto función de algoritmo)
ranges::destroy_at (C++20)	destruye un objeto en una dirección dada (objeto función de algoritmo)
ranges::destroy (C++20)	destruye un rango de objetos (objeto función de algoritmo)
ranges::destroy_n (C++20)	destruye un número de objetos en un rango (objeto función de algoritmo)

Sinopsis

#include <compare>
namespace std {
  // pointer Traits
  template<class Ptr>
  struct pointer_traits; // freestanding
  template<class T>
  struct pointer_traits<T*>; // freestanding
  // conversión de puntero
  template<class T>
  constexpr T* to_address(T* p) noexcept; // freestanding
  template<class Ptr>
  constexpr auto to_address(const Ptr& p) noexcept; // freestanding
  // alineación de punteros
  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);
  // gestión explícita del tiempo de vida
  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
  // etiqueta de argumento allocator
  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>::valor; // freestanding
  // construcción uses-allocator
  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;
  };
  // el asignador predeterminado
  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
  // algoritmos especializados
  // conceptos especiales de memoria
  template<class I>
  concept no-throw-input-iterator = /* ver descripción */; // exposición-solamente
  template<class I>
  concept no-throw-forward-iterator = /* ver descripción */; // exposición-solamente
  template<class S, class I>
  concept no-throw-sentinel-for = /* ver descripción */; // exposición-solamente
  template<class R>
  concept no-throw-input-range = /* ver descripción */; // exposición-solamente
  template<class R>
  concept no-throw-forward-range = /* ver descripción */; // exposición-solamente
  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<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<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<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<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);
  }
  // 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
  }
  // destruir
  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
  }
  // plantilla de clase 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 no es array
  template<class T>
  constexpr unique_ptr<T> make_unique(size_t n); // T es U[]
  template<class T, class... Args>
  /* sin especificar */ make_unique(Args&&...) = delete; // T es U[N]
  template<class T>
  constexpr unique_ptr<T> make_unique_for_overwrite(); // T no es array
  template<class T>
  constexpr unique_ptr<T> make_unique_for_overwrite(size_t n); // T es U[]
  template<class T, class... Args>
  /* sin especificar */ make_unique_for_overwrite(Args&&...) = delete; // T es 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>
  bool operator<(const unique_ptr<T1, D1>& x,
                 const unique_ptr<T2, D2>& y); // freestanding
  template<class T1, class D1, class T2, class D2>
  bool operator>(const unique_ptr<T1, D1>& x,
                 const unique_ptr<T2, D2>& y); // freestanding
  template<class T1, class D1, class T2, class D2>
  bool operator<=(const unique_ptr<T1, D1>& x,
                  const unique_ptr<T2, D2>& y); // freestanding
  template<class T1, class D1, class T2, class D2>
  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>
  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;
  // plantilla de clase shared_ptr
  template<class T>
  class shared_ptr;
  // creación de shared_ptr
  template<class T, class... Args>
  shared_ptr<T> make_shared(Args&&... args); // T no es array
  template<class T, class A, class... Args>
  shared_ptr<T> allocate_shared(const A& a, Args&&... args); // T no es array
  template<class T>
  shared_ptr<T> make_shared(size_t N); // T es U[]
  template<class T, class A>
  shared_ptr<T> allocate_shared(const A& a, size_t N); // T es U[]
  template<class T>
  shared_ptr<T> make_shared(); // T es U[N]
  template<class T, class A>
  shared_ptr<T> allocate_shared(const A& a); // T es U[N]
  template<class T>
  shared_ptr<T> make_shared(size_t N, const remove_extent_t<T>& u); // T es U[]
  template<class T, class A>
  shared_ptr<T> allocate_shared(const A& a,
                                size_t N,
                                const remove_extent_t<T>& u); // T es U[]
  template<class T>
  shared_ptr<T> make_shared(const remove_extent_t<T>& u); // T es U[N]
  template<class T, class A>
  shared_ptr<T> allocate_shared(const A& a, const remove_extent_t<T>& u); // T es U[N]
  template<class T>
  shared_ptr<T> make_shared_for_overwrite(); // T no es U[]
  template<class T, class A>
  shared_ptr<T> allocate_shared_for_overwrite(const A& a); // T no es U[]
  template<class T>
  shared_ptr<T> make_shared_for_overwrite(size_t N); // T es U[]
  template<class T, class A>
  shared_ptr<T> allocate_shared_for_overwrite(const A& a, size_t N); // T es U[]
  // comparaciones 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;
  // shared_ptr algoritmos especializados
  template<class T>
  void swap(shared_ptr<T>& a, shared_ptr<T>& b) noexcept;
  // conversiones 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;
  // shared_ptr E/S
  template<class E, class T, class Y>
  basic_ostream<E, T>& operator<<(basic_ostream<E, T>& os, const shared_ptr<Y>& p);
  // plantilla de clase weak_ptr
  template<class T>
  class weak_ptr;
  // Algoritmos especializados de weak_ptr
  template<class T>
  void swap(weak_ptr<T>& a, weak_ptr<T>& b) noexcept;
  // plantilla de clase 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;
  // soporte para hash
  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>>;
  // punteros inteligentes atómicos
  template<class T>
  struct atomic; // freestanding
  template<class T>
  struct atomic<shared_ptr<T>>;
  template<class T>
  struct atomic<weak_ptr<T>>;
  // plantilla de clase out_ptr_t
  template<class Smart, class Pointer, class... Args>
  class out_ptr_t; // freestanding
  // plantilla de función out_ptr
  template<class Pointer = void, class Smart, class... Args>
  auto out_ptr(Smart& s, Args&&... args); // freestanding
  // plantilla de clase inout_ptr_t
  template<class Smart, class Pointer, class... Args>
  class inout_ptr_t; // freestanding
  // plantilla de función inout_ptr
  template<class Pointer = void, class Smart, class... Args>
  auto inout_ptr(Smart& s, Args&&... args); // freestanding
  // plantilla de clase indirect
  template<class T, class Allocator = allocator<T>>
  class indirect;
  // soporte para hash
  template<class T, class Alloc>
  struct hash<indirect<T, Alloc>>;
  // plantilla de clase polimórfica
  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>>;
  }
}

Conceptos auxiliares

Nota: Estos nombres son solo para exposición, no forman parte de la interfaz.

template<class I>
concept no-throw-input-iterator = // solo para exposición
  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>; // solo para exposición
template<class R>
concept no-throw-input-range = // solo para exposición
  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 = // solo para exposición
  no-throw-input-iterator<I> &&
  forward_iterator<I> &&
  no-throw-sentinel-for<I, I>;
template<class R>
concept no-throw-forward-range = // solo para exposición
  no-throw-input-range<R> &&
  no-throw-forward-iterator<ranges::iterator_t<R>>;

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

cppreference.net

Namespaces

Variants

Standard library header <memory>

Contenidos

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

Construcción con asignador de memoria

Misceláneos

Gestión explícita del tiempo de vida

Soporte para recolector de basura

Almacenamiento no inicializado

Operaciones no miembro de punteros inteligentes

Creación de adaptador de puntero inteligente

Entidades similares a funciones

Almacenamiento no inicializado

Sinopsis

Conceptos auxiliares

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