Espacios de nombres
Variantes
Acciones

Archivo de encabezado de la biblioteca estándar <memory>

De cppreference.com
< cpp‎ | header
 
C++
Apoyo de compiladores
Implementaciones independientes y albergadas
Lenguaje
Biblioteca estándar
Encabezados de la biblioteca estándar
Requisitos denominados
Macros de prueba de característica (C++20)
Biblioteca de apoyo del lenguaje
Biblioteca de conceptos (C++20)
Biblioteca de diagnósticos
Biblioteca de gestión de memoria
Biblioteca de metaprogramación (C++11)
Biblioteca de servicios generales
Biblioteca de contenedores
Biblioteca de iteradores
Biblioteca de rangos (C++20)
Biblioteca de algoritmos
Biblioteca de cadenas
Biblioteca de procesamiento de texto
Biblioteca numérica
Biblioteca de fecha y hora
Biblioteca de entrada/salida
Biblioteca del sistema de archivos (C++17)
Biblioteca de apoyo de concurrencia (C++11)
Biblioteca de apoyo de ejecución (C++26)
Especificaciones técnicas
Índice de símbolos
Bibliotecas externas
 
Archivos de encabezado de la biblioteca estándar
 

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

Contenido

Clases

Rasgos de puntero
(C++11)
 Proporciona información sobre tipos similares a punteros.
(plantilla de clase) [editar]
Soporte de recolector de basura
(C++11)(eliminado en C++23)
 Lista los modelos de seguridad de puntero.
(clase) [editar]
Asignadores
El asignador de memoria por defecto.
(plantilla de clase) [editar]
(C++11)
 Proporciona información sobre los tipos de asignadores.
(plantilla de clase) [editar]
(C++11)
 Tipo de etiqueta utilizado para seleccionar sobrecargas de constructores conscientes de asignador.
(clase) [editar]
(C++11)
 Un objeto de tipo std::allocator_arg_t utilizado para seleccionar constructores conscientes de asignador.
(constante) [editar]
(C++11)
 Comprueba si el tipo especificado admite construcción con uso de asignador.
(plantilla de clase) [editar]
Almacenamiento sin inicializar
(en desuso en C++17)(eliminado en C++20)
 Un iterador que permite a los algoritmos estándar almacenar los resultados en memoria sin inicializar.
(plantilla de clase) [editar]
Punteros inteligentes
(C++11)
 Puntero inteligente con semántica de posesión de objeto única.
(plantilla de clase) [editar]
(C++11)
 Puntero inteligente con semántica de posesión de objeto compartida.
(plantilla de clase) [editar]
(C++11)
 Referencia débil a un objeto gestionado por std::shared_ptr.
(plantilla de clase) [editar]
(eliminado en C++17)
 Puntero inteligente con semántica de propiedad de objetos estricta.
(plantilla de clase) [editar]
Clases auxiliares
(C++20)
 Puntero compartido atómico.
(especialización de plantilla de clase) [editar]
(C++20)
 Puntero débil atómico.
(especialización de plantilla de clase) [editar]
(C++11)
 Proporciona un orden de tipo mixto basado en propietario de los punteros compartidos y débiles.
(plantilla de clase) [editar]
(C++11)
 Permite a un objeto crear un puntero compartido (shared_ptr) refiriéndose a sí mismo.
(plantilla de clase) [editar]
(C++11)
 Excepción lanzada cuando se accede a un puntero débil (weak_ptr) que se refiere a un objeto que ya ha sido destruido.
(clase) [editar]
(C++11)
 Eliminador por defecto para un puntero único (unique_ptr).
(plantilla de clase) [editar]
(C++11)
 Apoyo de generación de dispersión para std::unique_ptr.
(especialización de plantilla de clase) [editar]
(C++11)
 Apoyo de generación de dispersión para std::shared_ptr.
(especialización de plantilla de clase) [editar]

Funciones

Misceláneos
(C++20)
 Obtiene un puntero sin formato de un tipo similar a un puntero.
(plantilla de función) [editar]
(C++11)
 Obtiene la dirección real de un objeto, incluso si el operador & está sobrecargado.
(plantilla de función) [editar]
(C++11)
 Alinea un puntero en un búfer.
(función) [editar]
(C++20)
 Informa al compilador que un puntero está alineado.
(plantilla de función) [editar]
Soporte de recolector de basura
(C++11)(eliminado en C++23)
 Declara que un objeto no puede ser reciclado.
(función) [editar]
(C++11)(eliminado en C++23)
 Declara que un objeto puede ser reciclado.
(plantilla de función) [editar]
(C++11)(eliminado en C++23)
 Declara que una zona de memoria no contiene punteros rastreables.
(función) [editar]
(C++11)(eliminado en C++23)
 Cancela el efecto de std::declare_no_pointers.
(función) [editar]
(C++11)(eliminado en C++23)
 Devuelve el modelo actual de seguridad de puntero.
(función) [editar]
Almacenamiento sin inicializar
Copia un rango de objetos a una zona de memoria sin inicializar.
(plantilla de función) [editar]
(C++11)
 Copia un número de objetos a un área de memoria sin inicializar.
(plantilla de función) [editar]
Copia un objeto a una zona de memoria sin inicializar, definido por un rango.
(plantilla de función) [editar]
Copia un objeto a una zona de memoria sin inicializar, definido por un inicio y una cuenta.
(plantilla de función) [editar]
(C++17)
 Mueve un rango de objetos a un área de memoria sin inicializar.
(niebloid) [editar]
(C++17)
 Mueve un número de objetos a un área de memoria sin inicializar.
(niebloid) [editar]
(C++17)
 Construye objetos mediante la inicialización por defecto en un área de memoria sin inicializar, definido por un rango.
(plantilla de función) [editar]
(C++17)
 Construye objetos mediante la inicialización por defecto en un área de memoria sin inicializar, definido por un inicio y una cuenta.
(plantilla de función) [editar]
(C++17)
 Construye objetos mediante la inicialización de un valor en un área de memoria sin inicializar, definido por un rango.
(niebloid) [editar]
(C++17)
 Construye objetos mediante la inicialización de un valor en un área de memoria sin inicializar, definido por un inicio y una cuenta.
(niebloid) [editar]
(C++17)
 Destruye un objeto en una dirección dada.
(plantilla de función) [editar]
(C++17)
 Destruye un rango de objetos.
(plantilla de función) [editar]
(C++17)
 Destruye un número de objetos en un rango.
(plantilla de función) [editar]
(en desuso en C++17)(eliminado en C++20)
 Obtiene almacenamiento sin inicializar.
(plantilla de función) [editar]
(en desuso en C++17)(eliminado en C++20)
 Libera almacenamiento sin inicializar.
(plantilla de función) [editar]
Operaciones no miembro de punteros inteligentes
(C++14)(C++20)
 Crea un puntero único que gestiona a un nuevo objeto.
(plantilla de función) [editar]
(eliminado en C++20)(C++20)
 Se compara con otro

unique_ptr o con nullptr
(plantilla de función) [editar]

(C++20)
 Crea un puntero compartido que gestiona un nuevo objeto.
(plantilla de función) [editar]
(C++20)
 Crea un puntero compartido que gestiona un nuevo objeto asignado usando un asignador.
(plantilla de función) [editar]
(C++17)
 Aplica static_cast, dynamic_cast, const_cast, o reinterpret_cast al puntero almacenado.
(plantilla de función) [editar]
Devuelve el eliminador del tipo especificado, si se posee.
(plantilla de función) [editar]
(eliminado en C++20)(eliminado en C++20)(eliminado en C++20)(eliminado en C++20)(eliminado en C++20)(C++20)
 Se compara con otro

shared_ptr o con nullptr.
(plantilla de función) [editar]

Emite el valor del puntero almacenado a un flujo de salida.
(plantilla de función) [editar]
(C++11)
 Especializa el algoritmo std::swap.
(plantilla de función) [editar]
(C++11)
 Especializa el algoritmo std::swap.
(plantilla de función) [editar]
(C++11)
 Especializa el algoritmo std::swap.
(plantilla de función) [editar]
(en desuso en C++20)
 Especializa las operaciones atómicas para std::shared_ptr.
(plantilla de función) [editar]

Niebloids

Definido en el espacio de nombres std::ranges
Almacenamiento sin inicializar
(C++20)
 Copia un rango de objetos a un área de memoria sin inicializar.
(niebloid) [editar]
(C++20)
 Copia un número de objetos a un área de memoria sin inicializar.
(niebloid) [editar]
(C++20)
 Copia un objeto en un área de memoria sin inicializar, definido por un rango.
(niebloid) [editar]
(C++20)
 Copia un objeto a un área de memoria sin inicializar, definido por un inicio y una cuenta.
(niebloid) [editar]
(C++20)
 Mueve un rango de objetos a un área de memoria sin inicializar.
(niebloid) [editar]
(C++20)
 Mueve un número de objetos a un área de memoria sin inicializar.
(niebloid) [editar]
(C++20)
 Construye objetos mediante la

inicialización por defecto en un área de memoria sin inicializar, definido por un rango.
(niebloid) [editar]

(C++20)
(niebloid) [editar]
(C++20)
 Construye objetos mediante la inicialización de un valor en un área de memoria sin inicializar, definido por un rango.
(niebloid) [editar]
(C++20)
 Construye objetos mediante la inicialización de un valor en un área de memoria sin inicializar, definido por un inicio y una cuenta.
(niebloid) [editar]
(C++20)
 Destruye un objeto en una dirección dada.
(niebloid) [editar]
(C++20)
 Destruye un rango de objetos.
(niebloid) [editar]
(C++20)
 Destruye un número de objetos en un rango.
(niebloid) [editar]

[editar] Sinopsis

namespace std {
  // rasgos de puntero
  template<class Ptr> struct pointer_traits;
  template<class T> struct pointer_traits<T*>;
 
  // conversión de puntero
  template<class T>
    constexpr T* to_address(T* p) noexcept;
  template<class Ptr>
    auto to_address(const Ptr& p) noexcept;
 
  // seguridad de puntero
  enum class pointer_safety { relaxed, preferred, strict };
  void declare_reachable(void* p);
  template<class T>
    T* undeclare_reachable(T* p);
  void declare_no_pointers(char* p, size_t n);
  void undeclare_no_pointers(char* p, size_t n);
  pointer_safety get_pointer_safety() noexcept;
 
  // alineamiento de puntero
  void* align(size_t alignment, size_t size, void*& ptr, size_t& space);
  template<size_t N, class T>
    [[nodiscard]] constexpr T* assume_aligned(T* ptr);
 
  // etiqueta de argumento de asignador
  struct allocator_arg_t { explicit allocator_arg_t() = default; };
  inline constexpr allocator_arg_t allocator_arg{};
 
  // uses_allocator
  template<class T, class Alloc> struct uses_allocator;
 
  // uses_allocator
  template<class T, class Alloc>
    inline constexpr bool uses_allocator_v = uses_allocator<T, Alloc>::value;
 
  // construcción de uses_allocator
  template<class T, class Alloc, class... Args>
    constexpr auto uses_allocator_construction_args(const Alloc& alloc, Args&&... args)
      noexcept -> /* véase definición */;
  template<class T, class Alloc, class Tuple1, class Tuple2>
    constexpr auto uses_allocator_construction_args(
      const Alloc& alloc, piecewise_construct_t, Tuple1&& x, Tuple2&& y)
      noexcept -> /* véase definición */;
  template<class T, class Alloc>
    constexpr auto uses_allocator_construction_args(const Alloc& alloc)
      noexcept -> /* véase definición */;
  template<class T, class Alloc, class U, class V>
    constexpr auto uses_allocator_construction_args(const Alloc& alloc, U&& u, V&& v)
      noexcept -> /* véase definición */;
  template<class T, class Alloc, class U, class V>
    constexpr auto uses_allocator_construction_args(const Alloc& alloc,
      const pair<U,V>& pr)
      noexcept -> /* véase definición */;
  template<class T, class Alloc, class U, class V>
    constexpr auto uses_allocator_construction_args(const Alloc& alloc, pair<U,V>&& pr)
      noexcept -> /* véase definición */;
  template<class T, class Alloc, class... Args>
    constexpr T make_obj_using_allocator(const Alloc& alloc, Args&&... args);
  template<class T, class Alloc, class... Args>
    T* uninitialized_construct_using_allocator(T* p, const Alloc& alloc, Args&&... args);
 
  // rasgos de asignadores
  template<class Alloc> struct allocator_traits;
 
  // el asignador por defecto
  template<class T> class allocator;
  template<class T, class U>
    bool operator==(const allocator<T>&, const allocator<U>&) noexcept;
  template<class T, class U>
    bool operator!=(const allocator<T>&, const allocator<U>&) noexcept;
 
  // algoritmos especializados
  // conceptos de memoria especiales
  template<class I>
    concept __NoThrowInputIterator = /* véase definición */;   // solo exposición
  template<class I>
    concept __NoThrowForwardIterator = /* véase definición */; // solo exposición
  template<class S, class I>
    concept __NoThrowSentinel = /* véase definición */;        // solo exposición
  template<class R>
    concept __NoThrowInputRange = /* véase definición */;      // solo exposición
  template<class R>
    concept __NoThrowForwardRange = /* véase definición */;    // solo exposición
 
  template<class T>
    constexpr T* addressof(T& r) noexcept;
  template<class T>
    const T* addressof(const T&&) = delete;
  template<class ForwardIt>
    void uninitialized_default_construct(ForwardIt first, ForwardIt last);
  template<class ExecutionPolicy, class ForwardIt>
    void uninitialized_default_construct(ExecutionPolicy&& exec,
                                         ForwardIt first, ForwardIt last);
  template<class ForwardIt, class Size>
    ForwardIt uninitialized_default_construct_n(ForwardIt first, Size n);
  template<class ExecutionPolicy, class ForwardIt, class Size>
    ForwardIt uninitialized_default_construct_n(ExecutionPolicy&& exec,
                                                      ForwardIt first, Size n);
 
  namespace ranges {
    template<__NoThrowForwardIterator I, __NoThrowSentinel<I> S>
      requires DefaultConstructible<iter_value_t<I>>
        I uninitialized_default_construct(I first, S last);
    template<__NoThrowForwardRange R>
      requires DefaultConstructible<iter_value_t<iterator_t<R>>>
        borrowed_iterator_t<R> uninitialized_default_construct(R&& r);
 
    template<__NoThrowForwardIterator I>
      requires DefaultConstructible<iter_value_t<I>>
        I uninitialized_default_construct_n(I first, iter_difference_t<I> n);
  }
 
  template<class ForwardIt>
    void uninitialized_value_construct(ForwardIt first, ForwardIt last);
  template<class ExecutionPolicy, class ForwardIt>
    void uninitialized_value_construct(ExecutionPolicy&& exec,
                                       ForwardIt first, ForwardIt last);
  template<class ForwardIt, class Size>
    ForwardIt uninitialized_value_construct_n(ForwardIt first, Size n);
  template<class ExecutionPolicy, class ForwardIt, class Size>
    ForwardIt uninitialized_value_construct_n(ExecutionPolicy&& exec,
                                              ForwardIt first, Size n);
 
  namespace ranges {
    template<__NoThrowForwardIterator I, __NoThrowSentinel<I> S>
      requires DefaultConstructible<iter_value_t<I>>
        I uninitialized_value_construct(I first, S last);
    template<__NoThrowForwardRange R>
      requires DefaultConstructible<iter_value_t<iterator_t<R>>>
        borrowed_iterator_t<R> uninitialized_value_construct(R&& r);
 
    template<__NoThrowForwardIterator I>
      requires DefaultConstructible<iter_value_t<I>>
        I uninitialized_value_construct_n(I first, iter_difference_t<I> n);
  }
 
  template<class InputIt, class ForwardIt>
    ForwardIt uninitialized_copy(InputIt first, InputIt last, ForwardIt result);
  template<class ExecutionPolicy, class InputIt, class ForwardIt>
    ForwardIt uninitialized_copy(ExecutionPolicy&& exec,
                                 InputIt first, InputIt last, ForwardIt result);
  template<class InputIt, class Size, class ForwardIt>
    ForwardIt uninitialized_copy_n(InputIt first, Size n, ForwardIt result);
  template<class ExecutionPolicy, class InputIt, class Size, class ForwardIt>
    ForwardIt uninitialized_copy_n(ExecutionPolicy&& exec,
                                   InputIt first, Size n, ForwardIt result);
 
  namespace ranges {
    template<class I, class O>
    using uninitialized_copy_result = copy_result<I, O>;
    template<InputIterator I, Sentinel<I> S1,
             __NoThrowForwardIterator O, __NoThrowSentinel<O> S2>
      requires Constructible<iter_value_t<O>, iter_reference_t<I>>
        uninitialized_copy_result<I, O>
          uninitialized_copy(I ifirst, S1 ilast, O ofirst, S2 olast);
    template<InputRange IR, __NoThrowForwardRange OR>
      requires
        Constructible<iter_value_t<iterator_t<OR>>, iter_reference_t<iterator_t<IR>>>
        uninitialized_copy_result<borrowed_iterator_t<IR>, borrowed_iterator_t<OR>>
          uninitialized_copy(IR&& input_range, OR&& output_range);
 
    template<class I, class O>
      using uninitialized_copy_n_result = uninitialized_copy_result<I, O>;
    template<InputIterator I, __NoThrowForwardIterator O, __NoThrowSentinel<O> S>
      requires Constructible<iter_value_t<O>, iter_reference_t<I>>
        uninitialized_copy_n_result<I, O>
          uninitialized_copy_n(I ifirst, iter_difference_t<I> n, O ofirst, S olast);
  }
 
  template<class InputIt, class ForwardIt>
    ForwardIt uninitialized_move(InputIt first, InputIt last, ForwardIt result);
  template<class ExecutionPolicy, class InputIt, class ForwardIt>
    ForwardIt uninitialized_move(ExecutionPolicy&& exec,
                                 InputIt first, InputIt last, ForwardIt result);
  template<class InputIt, class Size, class ForwardIt>
    pair<InputIt, ForwardIt> uninitialized_move_n(InputIt first, Size n,
                                                  ForwardIt result);
  template<class ExecutionPolicy, class InputIt, class Size, class ForwardIt>
    pair<InputIt, ForwardIt> uninitialized_move_n(ExecutionPolicy&& exec,
                                                  InputIt first, Size n,
                                                  ForwardIt result);
 
  namespace ranges {
    template<class I, class O>
      using uninitialized_move_result = uninitialized_copy_result<I, O>;
    template<InputIterator I, Sentinel<I> S1,
             __NoThrowForwardIterator O, __NoThrowSentinel<O> S2>
      requires Constructible<iter_value_t<O>, iter_rvalue_reference_t<I>>
        uninitialized_move_result<I, O>
          uninitialized_move(I ifirst, S1 ilast, O ofirst, S2 olast);
    template<InputRange IR, __NoThrowForwardRange OR>
      requires Constructible<iter_value_t<iterator_t<OR>>,
                             iter_rvalue_reference_t<iterator_t<IR>>>
        uninitialized_move_result<borrowed_iterator_t<IR>, borrowed_iterator_t<OR>>
          uninitialized_move(IR&& input_range, OR&& output_range);
 
    template<class I, class O>
      using uninitialized_move_n_result = uninitialized_copy_result<I, O>;
    template<InputIterator I,
             __NoThrowForwardIterator O, __NoThrowSentinel<O> S>
      requires Constructible<iter_value_t<O>, iter_rvalue_reference_t<I>>
        uninitialized_move_n_result<I, O>
          uninitialized_move_n(I ifirst, iter_difference_t<I> n, O ofirst, S olast);
  }
 
  template<class ForwardIt, class T>
    void uninitialized_fill(ForwardIt first, ForwardIt last, const T& x);
  template<class ExecutionPolicy, class ForwardIt, class T>
    void uninitialized_fill(ExecutionPolicy&& exec,
                            ForwardIt first, ForwardIt last, const T& x);
  template<class ForwardIt, class Size, class T>
    ForwardIt uninitialized_fill_n(ForwardIt first, Size n, const T& x);
  template<class ExecutionPolicy, class ForwardIt, class Size, class T>
    ForwardIt uninitialized_fill_n(ExecutionPolicy&& exec,
                                   ForwardIt first, Size n, const T& x);
 
  namespace ranges {
    template<__NoThrowForwardIterator I, __NoThrowSentinel<I> S, class T>
      requires Constructible<iter_value_t<I>, const T&>
        I uninitialized_fill(I first, S last, const T& x);
    template<__NoThrowForwardRange R, class T>
      requires Constructible<iter_value_t<iterator_t<R>>, const T&>
        borrowed_iterator_t<R> uninitialized_fill(R&& r, const T& x);
 
    template<__NoThrowForwardIterator I, class T>
      requires Constructible<iter_value_t<I>, const T&>
        I uninitialized_fill_n(I first, iter_difference_t<I> n, const T& x);
  }
 
  template<class T>
    void destroy_at(T* location);
  template<class ForwardIt>
    void destroy(ForwardIt first, ForwardIt last);
  template<class ExecutionPolicy, class ForwardIt>
    void destroy(ExecutionPolicy&& exec,
                 ForwardIt first, ForwardIt last);
  template<class ForwardIt, class Size>
    ForwardIt destroy_n(ForwardIt first, Size n);
  template<class ExecutionPolicy, class ForwardIt, class Size>
    ForwardIt destroy_n(ExecutionPolicy&& exec,
                        ForwardIt first, Size n);
 
  namespace ranges {
    template<Destructible T>
      void destroy_at(T* location) noexcept;
 
    template<__NoThrowInputIterator I, __NoThrowSentinel<I> S>
      requires Destructible<iter_value_t<I>>
        I destroy(I first, S last) noexcept;
    template<__NoThrowInputRange R>
      requires Destructible<iter_value_t<iterator_t<R>>
        borrowed_iterator_t<R> destroy(R&& r) noexcept;
 
    template<__NoThrowInputIterator I>
      requires Destructible<iter_value_t<I>>
        I destroy_n(I first, iter_difference_t<I> n) noexcept;
  }
 
  // plantilla de clase unique_­ptr
  template<class T> struct default_delete;
  template<class T> struct default_delete<T[]>;
  template<class T, class D = default_delete<T>> class unique_ptr;
  template<class T, class D> class unique_ptr<T[], D>;
 
  template<class T, class... Args>
    unique_ptr<T> make_unique(Args&&... args);                           // T no es array
  template<class T>
    unique_ptr<T> make_unique(size_t n);                                 // T es U[]
  template<class T, class... Args>
    /* no especificado */ make_unique(Args&&...) = delete;               // T es U[N]
 
  template<class T>
    unique_ptr<T> make_unique_for_overwrite();                           // T no es array
  template<class T>
    unique_ptr<T> make_unique_for_overwrite(size_t n);                   // T es U[]
  template<class T, class... Args>
    /* no especificado */ make_unique_for_overwrite(Args&&...) = delete; // T es U[N]
 
  template<class T, class D>
    void swap(unique_ptr<T, D>& x, unique_ptr<T, D>& y) noexcept;
 
  template<class T1, class D1, class T2, class D2>
    bool operator==(const unique_ptr<T1, D1>& x, 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);
  template<class T1, class D1, class T2, class D2>
    bool operator<(const unique_ptr<T1, D1>& x, 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);
  template<class T1, class D1, class T2, class D2>
    bool operator<=(const unique_ptr<T1, D1>& x, 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);
 
  template<class T, class D>
    bool operator==(const unique_ptr<T, D>& x, nullptr_t) noexcept;
  template<class T, class D>
    bool operator==(nullptr_t, const unique_ptr<T, D>& y) noexcept;
  template<class T, class D>
    bool operator!=(const unique_ptr<T, D>& x, nullptr_t) noexcept;
  template<class T, class D>
    bool operator!=(nullptr_t, const unique_ptr<T, D>& y) noexcept;
  template<class T, class D>
    bool operator<(const unique_ptr<T, D>& x, nullptr_t);
  template<class T, class D>
    bool operator<(nullptr_t, const unique_ptr<T, D>& y);
  template<class T, class D>
    bool operator>(const unique_ptr<T, D>& x, nullptr_t);
  template<class T, class D>
    bool operator>(nullptr_t, const unique_ptr<T, D>& y);
  template<class T, class D>
    bool operator<=(const unique_ptr<T, D>& x, nullptr_t);
  template<class T, class D>
    bool operator<=(nullptr_t, const unique_ptr<T, D>& y);
  template<class T, class D>
    bool operator>=(const unique_ptr<T, D>& x, nullptr_t);
  template<class T, class D>
    bool operator>=(nullptr_t, const unique_ptr<T, D>& y);
 
  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);
 
  // clase 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>
    bool operator!=(const shared_ptr<T>& a, const shared_ptr<U>& b) noexcept;
  template<class T, class U>
    bool operator<(const shared_ptr<T>& a, const shared_ptr<U>& b) noexcept;
  template<class T, class U>
    bool operator>(const shared_ptr<T>& a, const shared_ptr<U>& b) noexcept;
  template<class T, class U>
    bool operator<=(const shared_ptr<T>& a, const shared_ptr<U>& b) noexcept;
  template<class T, class U>
    bool 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>
    bool operator==(nullptr_t, const shared_ptr<T>& y) noexcept;
  template<class T>
    bool operator!=(const shared_ptr<T>& x, nullptr_t) noexcept;
  template<class T>
    bool operator!=(nullptr_t, const shared_ptr<T>& y) noexcept;
  template<class T>
    bool operator<(const shared_ptr<T>& x, nullptr_t) noexcept;
  template<class T>
    bool operator<(nullptr_t, const shared_ptr<T>& y) noexcept;
  template<class T>
    bool operator>(const shared_ptr<T>& x, nullptr_t) noexcept;
  template<class T>
    bool operator>(nullptr_t, const shared_ptr<T>& y) noexcept;
  template<class T>
    bool operator<=(const shared_ptr<T>& x, nullptr_t) noexcept;
  template<class T>
    bool operator<=(nullptr_t, const shared_ptr<T>& y) noexcept;
  template<class T>
    bool operator>=(const shared_ptr<T>& x, nullptr_t) noexcept;
  template<class T>
    bool operator>=(nullptr_t, const shared_ptr<T>& y) noexcept;
 
  // algoritmos especializados de shared_ptr
  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;
 
  // E/S de shared_ptr
  template<class E, class T, class Y>
    basic_ostream<E, T>& operator<<(basic_ostream<E, T>& os, const shared_ptr<Y>& p);
 
  // 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;
 
  // plantilla de clase enable_shared_from_this
  template<class T> class enable_shared_from_this;
 
  // soporte hash (resumen)
  template<class T> struct hash;
  template<class T, class D> struct hash<unique_ptr<T, D>>;
  template<class T> struct hash<shared_ptr<T>>;
 
  // punteros inteligentes atómicos
  template<class T> struct atomic;
  template<class T> struct atomic<shared_ptr<T>>;
  template<class T> struct atomic<weak_ptr<T>>;
 
  // acceso atómico de shared_ptr
  template<class T>
  bool atomic_is_lock_free(const shared_ptr<T>* p);
  template<class T>
  shared_ptr<T> atomic_load(const shared_ptr<T>* p);
  template<class T>
  shared_ptr<T> atomic_load_explicit(const shared_ptr<T>* p, memory_order mo);
  template<class T>
  void atomic_store(shared_ptr<T>* p, shared_ptr<T> r);
  template<class T>
  void atomic_store_explicit(shared_ptr<T>* p, shared_ptr<T> r, memory_order mo);
  template<class T>
  shared_ptr<T> atomic_exchange(shared_ptr<T>* p, shared_ptr<T> r);
  template<class T>
  shared_ptr<T> atomic_exchange_explicit(shared_ptr<T>* p, shared_ptr<T> r,
                                         memory_order mo);
  template<class T>
  bool atomic_compare_exchange_weak(shared_ptr<T>* p, shared_ptr<T>* v, shared_ptr<T> w);
  template<class T>
  bool atomic_compare_exchange_strong(shared_ptr<T>* p, shared_ptr<T>* v, shared_ptr<T> w);
  template<class T>
  bool atomic_compare_exchange_weak_explicit(shared_ptr<T>* p, shared_ptr<T>* v,
                                             shared_ptr<T> w, memory_order success,
                                             memory_order failure);
  template<class T>
  bool atomic_compare_exchange_strong_explicit(shared_ptr<T>* p, shared_ptr<T>* v,
                                               shared_ptr<T> w, memory_order success, 
                                               memory_order failure);
}

[editar] Conceptos auxiliares

template<class I>
concept __NoThrowInputIterator = // solo exposición
  InputIterator<I> &&
  is_lvalue_reference_v<iter_reference_t<I>> &&
  Same<remove_cvref_t<iter_reference_t<I>>, iter_value_t<I>>;
 
template<class S, class I>
concept __NoThrowSentinel = Sentinel<S, I>; // solo exposición
 
template<class R>
concept __NoThrowInputRange = // solo exposición
  Range<R> &&
  __NoThrowInputIterator<iterator_t<R>> &&
  __NoThrowSentinel<sentinel_t<R>, iterator_t<R>>;
 
template<class I>
concept __NoThrowForwardIterator = // solo exposición
  __NoThrowInputIterator<I> &&
  ForwardIterator<I> &&
  __NoThrowSentinel<I, I>;
 
template<class R>
concept __NoThrowForwardRange = // solo exposición
  __NoThrowInputRange<R> &&
  __NoThrowForwardIterator<iterator_t<R>>;

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

[editar] Plantilla de clase std::pointer_traits

namespace std {
  template <class Ptr> struct pointer_traits {
    using pointer = Ptr;
    using element_type = /* véase definición */;
    using difference_type = /* véase definición */;
    template <class U> using rebind = /* véase definición */;
    static pointer pointer_to(/* véase definición */ r);
  };
 
  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(/* véase definición */ r) noexcept;
  };
}

[editar] Clase std::allocator_arg_t

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

[editar] 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            = /* véase definición */;
    using const_pointer      = /* véase definición */;
    using void_pointer       = /* véase definición */;
    using const_void_pointer = /* véase definición */;
 
    using difference_type    = /* véase definición */;
    using size_type          = /* véase definición */;
 
    using propagate_on_container_copy_assignment = /* véase definición */;
    using propagate_on_container_move_assignment = /* véase definición */;
    using propagate_on_container_swap            = /* véase definición */;
    using is_always_equal                        = /* véase definición */;
 
    template<class T> using rebind_alloc = /* véase definición */;
    template<class T> using rebind_traits = allocator_traits<rebind_alloc<T>>;
 
    [[nodiscard]] static pointer allocate(Alloc& a, size_type n);
    [[nodiscard]] static pointer allocate(Alloc& a, size_type n, const_void_pointer hint);
 
    static void deallocate(Alloc& a, pointer p, size_type n);
 
    template<class T, class... Args>
      static void construct(Alloc& a, T* p, Args&&... args);
 
    template<class T>
      static void destroy(Alloc& a, T* p);
 
    static size_type max_size(const Alloc& a) noexcept;
 
    static Alloc select_on_container_copy_construction(const Alloc& rhs);
  };
}

[editar] 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;
    using is_always_equal                        = true_type;
 
    constexpr allocator() noexcept;
    constexpr allocator(const allocator&) noexcept;
    template<class U> constexpr allocator(const allocator<U>&) noexcept;
    ~allocator();
    allocator& operator=(const allocator&) = default;
 
    [[nodiscard]] T* allocate(size_t n);
    void deallocate(T* p, size_t n);
  };
}

[editar] Plantilla de clase std::default_delete

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

[editar] Plantilla de clase std::unique_ptr

namespace std {
  template<class T, class D = default_delete<T>> class unique_ptr {
  public:
    using pointer      = /* véase definición */;
    using element_type = T;
    using deleter_type = D;
 
    // constructores
    constexpr unique_ptr() noexcept;
    explicit unique_ptr(pointer p) noexcept;
    unique_ptr(pointer p, /* véase definición */ d1) noexcept;
    unique_ptr(pointer p, /* véase definición */ d2) noexcept;
    unique_ptr(unique_ptr&& u) noexcept;
    constexpr unique_ptr(nullptr_t) noexcept;
    template<class U, class E>
      unique_ptr(unique_ptr<U, E>&& u) noexcept;
 
    // destructor
    ~unique_ptr();
 
    // asignación
    unique_ptr& operator=(unique_ptr&& u) noexcept;
    template<class U, class E>
      unique_ptr& operator=(unique_ptr<U, E>&& u) noexcept;
    unique_ptr& operator=(nullptr_t) noexcept;
 
    // observadores
    add_lvalue_reference_t<T> operator*() const;
    pointer operator->() const noexcept;
    pointer get() const noexcept;
    deleter_type& get_deleter() noexcept;
    const deleter_type& get_deleter() const noexcept;
    explicit operator bool() const noexcept;
 
    // modificadores
    pointer release() noexcept;
    void reset(pointer p = pointer()) noexcept;
    void swap(unique_ptr& u) noexcept;
 
    // deshabilitar copia a partir de 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      = /* véase definición */;
    using element_type = T;
    using deleter_type = D;
 
    // constructores
    constexpr unique_ptr() noexcept;
    template<class U> explicit unique_ptr(U p) noexcept;
    template<class U> unique_ptr(U p, /* véase definición */ d) noexcept;
    template<class U> unique_ptr(U p, /* véase definición */ d) noexcept;
    unique_ptr(unique_ptr&& u) noexcept;
    template<class U, class E>
      unique_ptr(unique_ptr<U, E>&& u) noexcept;
    constexpr unique_ptr(nullptr_t) noexcept;
 
    // destructor
    ~unique_ptr();
 
    // asignación
    unique_ptr& operator=(unique_ptr&& u) noexcept;
    template<class U, class E>
      unique_ptr& operator=(unique_ptr<U, E>&& u) noexcept;
    unique_ptr& operator=(nullptr_t) noexcept;
 
    // observadores
    T& operator[](size_t i) const;
    pointer get() const noexcept;
    deleter_type& get_deleter() noexcept;
    const deleter_type& get_deleter() const noexcept;
    explicit operator bool() const noexcept;
 
    // modificadores
    pointer release() noexcept;
    template<class U> void reset(U p) noexcept;
    void reset(nullptr_t = nullptr) noexcept;
    void swap(unique_ptr& u) noexcept;
 
    // deshabilitar copia a partir de lvalue
    unique_ptr(const unique_ptr&) = delete;
    unique_ptr& operator=(const unique_ptr&) = delete;
  };
}

[editar] Clase std::bad_weak_ptr

namespace std {
  class bad_weak_ptr : public exception {
  public:
    bad_weak_ptr() noexcept;
  };
}

[editar] 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;
  };
 
  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>;
}

[editar] 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;
  };
 
  template<class T>
    weak_ptr(shared_ptr<T>) -> weak_ptr<T>;
}

[editar] 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 */;
  };
}

[editar] 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 exposición
  };
}

[editar] Plantilla de clase especialización de 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 exposición
  };
}

[editar] Plantilla de clase std::atomic's specialization for 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 exposición
  };
}
Obtenido de «https://es.cppreference.com/mwiki/index.php?title=cpp/header/memory&oldid=43586»