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

 

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

Apoyo del lenguaje <cfloat> <climits> <compare>(C++20) <coroutine>(C++20) <csetjmp> <csignal> <cstdarg> <cstddef> <cstdint>(C++11) <cstdlib> <exception> <initializer_list>(C++11)    <limits> <new> <source_location>(C++20) <stdfloat>(C++23) <typeinfo> <version>(C++20) Conceptos <concepts>(C++20) Diagnósticos <cassert> <cerrno> <debugging>(C++26) <stacktrace>(C++23) <stdexcept> <system_error>(C++11) Gestión de memoria <memory> <memory_resource>(C++17) <scoped_allocator>(C++11) Metaprogramación <type_traits>(C++11) <ratio>(C++11)

Servicios generales <any>(C++17) <bitset> <bit>(C++20) <charconv>(C++17) <expected>(C++23) <format>(C++20) <functional> <optional>(C++17) <tuple>(C++11) <typeindex>(C++11) <utility> <variant>(C++17) Contenedores <array>(C++11) <deque> <flat_map>(C++23) <flat_set>(C++23) <forward_list>(C++11) <inplace_vector>(C++26)    <list> <map> <mdspan>(C++23) <queue> <set> <span>(C++20) <stack> <unordered_map>(C++11) <unordered_set>(C++11) <vector> Iteradores <iterator> Rangos <generator>(C++23) <ranges>(C++20)

Algoritmos <algorithm> <numeric> Cadenas <cctype> <cstring> <cuchar>(C++11) <cwchar> <cwctype> <string_view>(C++17) <string> Procesamiento de texto <clocale> <codecvt>(C++11/17/26*) <locale> <regex>(C++11) <text_encoding>(C++26)    Numéricos <cfenv>(C++11) <cmath> <complex> <linalg>(C++26) <numbers>(C++20) <random>(C++11) <simd>(C++26) <valarray> Tiempo <chrono>(C++11) <ctime> Compatibilidad con C <ccomplex>(C++11/17/20*) <ciso646>(hasta C++20) <cstdalign>(C++11/17/20*) <cstdbool>(C++11/17/20*) <ctgmath>(C++11/17/20*)

Entrada/Salida <cinttypes>(C++11) <cstdio> <filesystem>(C++17) <fstream> <iomanip> <iosfwd> <iostream> <ios> <istream> <ostream> <print>(C++23) <spanstream>(C++23) <sstream> <streambuf> <strstream>(C++98/26*) <syncstream>(C++20) Apoyo para concurrencia <atomic>(C++11) <barrier>(C++20) <condition_variable>(C++11) <future>(C++11) <hazard_pointer>(C++26) <latch>(C++20) <mutex>(C++11) <rcu>(C++26) <semaphore>(C++20) <shared_mutex>(C++14) <stdatomic.h>(C++23) <stop_token>(C++20) <thread>(C++11) Apoyo de ejecución <execution>(C++17)

 

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

Clases
Rasgos de puntero
pointer_traits (C++11)	Proporciona información sobre tipos similares a punteros. (plantilla de clase)
Soporte de recolector de basura
pointer_safety (C++11)(eliminado en C++23)	Lista los modelos de seguridad de puntero. (clase)
Asignadores
allocator	El asignador de memoria por defecto. (plantilla de clase)
allocator_traits (C++11)	Proporciona información sobre los tipos de asignadores. (plantilla de clase)
allocator_arg_t (C++11)	Tipo de etiqueta utilizado para seleccionar sobrecargas de constructores conscientes de asignador. (clase)
allocator_arg (C++11)	Un objeto de tipo std::allocator_arg_t utilizado para seleccionar constructores conscientes de asignador. (constante)
uses_allocator (C++11)	Comprueba si el tipo especificado admite construcción con uso de asignador. (plantilla de clase)
Almacenamiento sin inicializar
raw_storage_iterator (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)
Punteros inteligentes
unique_ptr (C++11)	Puntero inteligente con semántica de posesión de objeto única. (plantilla de clase)
shared_ptr (C++11)	Puntero inteligente con semántica de posesión de objeto compartida. (plantilla de clase)
weak_ptr (C++11)	Referencia débil a un objeto gestionado por std::shared_ptr. (plantilla de clase)
auto_ptr (eliminado en C++17)	Puntero inteligente con semántica de propiedad de objetos estricta. (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 un orden de tipo mixto basado en propietario de los punteros compartidos y débiles. (plantilla de clase)
enable_shared_from_this (C++11)	Permite a un objeto crear un puntero compartido (shared_ptr) refiriéndose a sí mismo. (plantilla de clase)
bad_weak_ptr (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)
default_delete (C++11)	Eliminador por defecto para un puntero único (unique_ptr). (plantilla de clase)
std::hash<std::unique_ptr> (C++11)	Apoyo de generación de dispersión para std::unique_ptr. (especialización de plantilla de clase)
std::hash<std::shared_ptr> (C++11)	Apoyo de generación de dispersión para std::shared_ptr. (especialización de plantilla de clase)
Funciones
Misceláneos
to_address (C++20)	Obtiene un puntero sin formato de un tipo similar a un 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)
Soporte de 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 una zona 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 puntero. (función)
Almacenamiento sin inicializar
uninitialized_copy	Copia un rango de objetos a una zona de memoria sin inicializar. (plantilla de función)
uninitialized_copy_n (C++11)	Copia un número de objetos a un área de memoria sin inicializar. (plantilla de función)
uninitialized_fill	Copia un objeto a una zona de memoria sin inicializar, definido por un rango. (plantilla de función)
uninitialized_fill_n	Copia un objeto a una zona de memoria sin inicializar, definido por un inicio y una cuenta. (plantilla de función)
uninitialized_move (C++17)	Mueve un rango de objetos a un área de memoria sin inicializar. (niebloid)
uninitialized_move_n (C++17)	Mueve un número de objetos a un área de memoria sin inicializar. (niebloid)
uninitialized_default_construct (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)
uninitialized_default_construct_n (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)
uninitialized_value_construct (C++17)	Construye objetos mediante la inicialización de un valor en un área de memoria sin inicializar, definido por un rango. (niebloid)
uninitialized_value_construct_n (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)
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 un número de objetos en un rango. (plantilla de función)
get_temporary_buffer (en desuso en C++17)(eliminado en C++20)	Obtiene almacenamiento sin inicializar. (plantilla de función)
return_temporary_buffer (en desuso en C++17)(eliminado en C++20)	Libera almacenamiento sin inicializar. (plantilla de función)
Operaciones no miembro de punteros inteligentes
make_uniquemake_unique_for_overwrite (C++14)(C++20)	Crea un puntero único que gestiona a un nuevo objeto. (plantilla de función)
operator==operator!=operator<operator<=operator>operator>=operator<=> (eliminado en C++20)(C++20)	Se compara con otro unique_ptr o con nullptr (plantilla de función)
make_sharedmake_shared_for_overwrite (C++20)	Crea un puntero compartido que gestiona un nuevo objeto. (plantilla de función)
allocate_sharedallocate_shared_for_overwrite (C++20)	Crea un puntero compartido que gestiona un nuevo objeto asignado usando un asignador. (plantilla de función)
static_pointer_castdynamic_pointer_castconst_pointer_castreinterpret_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 eliminador del tipo especificado, si se posee. (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)	Se compara con otro shared_ptr o con nullptr. (plantilla de función)
operator<<	Emite el valor del puntero almacenado 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::weak_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::atomic_is_lock_free(std::shared_ptr)std::atomic_load(std::shared_ptr)std::atomic_load_explicit(std::shared_ptr)std::atomic_store(std::shared_ptr)std::atomic_store_explicit(std::shared_ptr)std::atomic_exchange(std::shared_ptr)std::atomic_exchange_explicit(std::shared_ptr)std::atomic_compare_exchange_weak(std::shared_ptr)std::atomic_compare_exchange_strong(std::shared_ptr)std::atomic_compare_exchange_weak_explicit(std::shared_ptr)std::atomic_compare_exchange_strong_explicit(std::shared_ptr) (en desuso en C++20)

Especializa las operaciones atómicas para std::shared_ptr. (plantilla de función)

Niebloids
Definido en el espacio de nombres std::ranges
Almacenamiento sin inicializar
ranges::uninitialized_copy (C++20)	Copia un rango de objetos a un área de memoria sin inicializar. (niebloid)
ranges::uninitialized_copy_n (C++20)	Copia un número de objetos a un área de memoria sin inicializar. (niebloid)
ranges::uninitialized_fill (C++20)	Copia un objeto en un área de memoria sin inicializar, definido por un rango. (niebloid)
ranges::uninitialized_fill_n (C++20)	Copia un objeto a un área de memoria sin inicializar, definido por un inicio y una cuenta. (niebloid)
ranges::uninitialized_move (C++20)	Mueve un rango de objetos a un área de memoria sin inicializar. (niebloid)
ranges::uninitialized_move_n (C++20)	Mueve un número de objetos a un área de memoria sin inicializar. (niebloid)
ranges::uninitialized_default_construct (C++20)	Construye objetos mediante la inicialización por defecto en un área de memoria sin inicializar, definido por un rango. (niebloid)
ranges::uninitialized_default_construct_n (C++20)	(niebloid)
ranges::uninitialized_value_construct (C++20)	Construye objetos mediante la inicialización de un valor en un área de memoria sin inicializar, definido por un rango. (niebloid)
ranges::uninitialized_value_construct_n (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)
ranges::destroy_at (C++20)	Destruye un objeto en una dirección dada. (niebloid)
ranges::destroy (C++20)	Destruye un rango de objetos. (niebloid)
ranges::destroy (C++20)	Destruye un número de objetos en un rango. (niebloid)

Sinopsis

namespace std {// rasgos de punterotemplate<class Ptr>struct pointer_traits;template<class T>struct pointer_traits<T*>;   // conversión de punterotemplate<class T>constexpr T* to_address(T* p)noexcept;template<class Ptr>auto to_address(const Ptr& p)noexcept;   // seguridad de punteroenumclass 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 punterovoid* 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 asignadorstruct allocator_arg_t {explicit allocator_arg_t()=default;};inlineconstexpr allocator_arg_t allocator_arg{};   // uses_allocatortemplate<class T, class Alloc>struct uses_allocator;   // uses_allocatortemplate<class T, class Alloc>inlineconstexprbool uses_allocator_v = uses_allocator<T, Alloc>::value;   // construcción de uses_allocatortemplate<class T, class Alloc, class... Args>constexprauto uses_allocator_construction_args(const Alloc& alloc, Args&&... args)noexcept->/* véase definición */;template<class T, class Alloc, class Tuple1, class Tuple2>constexprauto uses_allocator_construction_args(const Alloc& alloc, piecewise_construct_t, Tuple1&& x, Tuple2&& y)noexcept->/* véase definición */;template<class T, class Alloc>constexprauto uses_allocator_construction_args(const Alloc& alloc)noexcept->/* véase definición */;template<class T, class Alloc, class U, class V>constexprauto 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>constexprauto 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>constexprauto 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 asignadorestemplate<class Alloc>struct allocator_traits;   // el asignador por defectotemplate<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 especialestemplate<class I> concept __NoThrowInputIterator =/* véase definición */;// solo exposicióntemplate<class I> concept __NoThrowForwardIterator =/* véase definición */;// solo exposicióntemplate<class S, class I> concept __NoThrowSentinel =/* véase definición */;// solo exposicióntemplate<class R> concept __NoThrowInputRange =/* véase definición */;// solo exposicióntemplate<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_­ptrtemplate<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 arraytemplate<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 arraytemplate<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_ptrclass bad_weak_ptr;   // plantilla de clase shared_ptrtemplate<class T>class shared_ptr;   // creación de shared_ptrtemplate<class T, class... Args> shared_ptr<T> make_shared(Args&&... args);// T no es arraytemplate<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_ptrtemplate<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_ptrtemplate<class T>void swap(shared_ptr<T>& a, shared_ptr<T>& b)noexcept;   // conversiones de shared_ptrtemplate<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_deletertemplate<class D, class T> D* get_deleter(const shared_ptr<T>& p)noexcept;   // E/S de shared_ptrtemplate<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_ptrtemplate<class T>class weak_ptr;   // algoritmos especializados de weak_ptrtemplate<class T>void swap(weak_ptr<T>& a, weak_ptr<T>& b)noexcept;   // plantilla de clase owner_lesstemplate<class T =void>struct owner_less;   // plantilla de clase enable_shared_from_thistemplate<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ómicostemplate<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_ptrtemplate<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);}

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.

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*;staticconstexpr pointer pointer_to(/* véase definición */ r)noexcept;};}

Clase std::allocator_arg_t

namespace std {struct allocator_arg_t {explicit allocator_arg_t()=default;};inlineconstexpr 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 =/* 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);   staticvoid deallocate(Alloc& a, pointer p, size_type n);   template<class T, class... Args>staticvoid construct(Alloc& a, T* p, Args&&... args);   template<class T>staticvoid destroy(Alloc& a, T* p);   static size_type max_size(const Alloc& a)noexcept;   static 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;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);};}

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

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;   // constructoresconstexpr 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->()constnoexcept; pointer get()constnoexcept; deleter_type& get_deleter()noexcept;const deleter_type& get_deleter()constnoexcept;explicit operator bool()constnoexcept;   // 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;   // constructoresconstexpr 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()constnoexcept; deleter_type& get_deleter()noexcept;const deleter_type& get_deleter()constnoexcept;explicit operator bool()constnoexcept;   // 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;};}

Clase std::bad_weak_ptr

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

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>;   // constructoresconstexpr 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);   // modificadoresvoid 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()constnoexcept; T& operator*()constnoexcept; T* operator->()constnoexcept; element_type& operator[](ptrdiff_t i)const;long use_count()constnoexcept;explicit operator bool()constnoexcept;template<class U>bool owner_before(const shared_ptr<U>& b)constnoexcept;template<class U>bool owner_before(const weak_ptr<U>& b)constnoexcept;};   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>;   // constructoresconstexpr 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;   // modificadoresvoid swap(weak_ptr& r)noexcept;void reset()noexcept;   // observadoreslong use_count()constnoexcept;bool expired()constnoexcept; shared_ptr<T> lock()constnoexcept;template<class U>bool owner_before(const shared_ptr<U>& b)constnoexcept;template<class U>bool owner_before(const weak_ptr<U>& b)constnoexcept;};   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>&)constnoexcept;bool operator()(const shared_ptr<T>&, const weak_ptr<T>&)constnoexcept;bool operator()(const weak_ptr<T>&, const shared_ptr<T>&)constnoexcept;};   template<class T>struct owner_less<weak_ptr<T>>{bool operator()(const weak_ptr<T>&, const weak_ptr<T>&)constnoexcept;bool operator()(const shared_ptr<T>&, const weak_ptr<T>&)constnoexcept;bool operator()(const weak_ptr<T>&, const shared_ptr<T>&)constnoexcept;};   template<>struct owner_less<void>{template<class T, class U>bool operator()(const shared_ptr<T>&, const shared_ptr<U>&)constnoexcept;template<class T, class U>bool operator()(const shared_ptr<T>&, const weak_ptr<U>&)constnoexcept;template<class T, class U>bool operator()(const weak_ptr<T>&, const shared_ptr<U>&)constnoexcept;template<class T, class U>bool operator()(const weak_ptr<T>&, const weak_ptr<U>&)constnoexcept;   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()constnoexcept;   private: mutable weak_ptr<T> weak_this;// solo exposición};}

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>;staticconstexprbool is_always_lock_free =/* definido por la implementación */;   bool is_lock_free()constnoexcept;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)constnoexcept; operator shared_ptr<T>()constnoexcept;   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};}

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>;staticconstexprbool is_always_lock_free =/* definido por la implementación */;   bool is_lock_free()constnoexcept;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)constnoexcept; operator weak_ptr<T>()constnoexcept;   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};}