std::atomic_...<std::shared_ptr>

 

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

 

Biblioteca de servicios

Apoyo del lenguaje Apoyo de tipos (tipos básicos, RTTI) Biblioteca de macros de prueba de característica(C++20) Servicios del programa Apoyo de corrutinas(C++20) Funciones variádicas is_constant_evaluated (C++20) is_within_lifetime (C++26) initializer_list (C++11) source_location (C++20) Comparación de tres vías three_way_comparablethree_way_comparable_with (C++20)(C++20) strong_ordering (C++20) weak_ordering (C++20) partial_ordering (C++20) common_comparison_category (C++20) compare_three_way_result (C++20) compare_three_way (C++20) strong_order (C++20) weak_order (C++20) partial_order (C++20) compare_strong_order_fallback (C++20) compare_weak_order_fallback (C++20) compare_partial_order_fallback (C++20)   is_eqis_ltis_lteq (C++20)(C++20)(C++20)   is_neqis_gtis_gteq (C++20)(C++20)(C++20)

Servicios generales Objetos función Manipulación de bits(C++20) bitset hash (C++11) Operadores relacionales(en desuso en C++20) rel_ops::operator!=rel_ops::operator>    rel_ops::operator<=rel_ops::operator>= Funciones de comparación de enteros cmp_equalcmp_lesscmp_less_than (C++20)(C++20)(C++20)   cmp_not_equalcmp_greatercmp_greater_than (C++20)(C++20)(C++20) in_range (C++20) Intercambio y operaciones de tipos swap ranges::swap (C++20) exchange (C++14) declval (C++11) to_underlying (C++23) forward (C++11) forward_like (C++23) move (C++11) move_if_noexcept (C++11) as_const (C++17) Tipos vocabulario comunes pair tuple (C++11) optional (C++17) any (C++17) variant (C++17) tuple_size (C++11) tuple_element (C++11) apply (C++17) make_from_tuple (C++17) expected (C++23)

 

Gestión de memoria dinámica

Punteros inteligentes unique_ptr (C++11) shared_ptr (C++11) weak_ptr (C++11) auto_ptr (hasta C++17) owner_less (C++11) enable_shared_from_this (C++11) bad_weak_ptr (C++11) default_delete (C++11) out_ptr_t (C++23) inout_ptr_t (C++23) Asignadores de memoria allocator allocator_traits (C++11) allocation_result (C++23) allocate_at_least (C++23) allocator_arg_t (C++11) allocator_arg (C++11) uses_allocator (C++11) uses_allocator_construction_args (C++20) make_obj_using_allocator (C++20) uninitialized_construct_using_allocator (C++20) scoped_allocator_adaptor (C++11) pmr::polymorphic_allocator (C++17) Recursos de memoria pmr::memory_resource (C++17) pmr::get_default_resource (C++17) pmr::set_default_resource (C++17) pmr::new_delete_resource (C++17) pmr::null_memory_resource (C++17) pmr::synchronized_pool_resource (C++17) pmr::unsynchronized_pool_resource (C++17) pmr::monotonic_buffer_resource (C++17) pmr::pool_options (C++17) Almacenamiento no inicializado raw_storage_iterator (hasta C++20) get_temporary_buffer (hasta C++20) return_temporary_buffer (hasta C++20)

Algoritmos de memoria no inicializada uninitialized_copy uninitialized_fill uninitialized_move (C++17) uninitialized_default_construct (C++17) uninitialized_value_construct (C++17) destroy (C++17) destroy_at (C++17) uninitialized_copy_n (C++11) uninitialized_fill_n uninitialized_move_n (C++17) uninitialized_default_construct_n (C++17) uninitialized_value_construct_n (C++17) destroy_n (C++17) construct_at (C++20) Algoritmos restringidos de memoria no inicializada ranges::uninitialized_copy (C++20) ranges::uninitialized_fill (C++20) ranges::uninitialized_move (C++20) ranges::uninitialized_default_construct (C++20) ranges::uninitialized_value_construct (C++20) ranges::destroy (C++20) ranges::destroy_at (C++20) ranges::uninitialized_copy_n (C++20) ranges::uninitialized_fill_n (C++20) ranges::uninitialized_move_n (C++20) ranges::uninitialized_default_construct_n (C++20) ranges::uninitialized_value_construct_n (C++20) ranges::destroy_n (C++20) ranges::construct_at (C++20) Apoyo para recolección de basura declare_reachable (C++11)(hasta C++23) undeclare_reachable (C++11)(hasta C++23) declare_no_pointers (C++11)(hasta C++23) undeclare_no_pointers (C++11)(hasta C++23) pointer_safety (C++11)(hasta C++23) get_pointer_safety (C++11)(hasta C++23) Misceláneos pointer_traits (C++11) to_address (C++20) addressof (C++11) align (C++11) assume_aligned (C++20) Biblioteca de C malloc aligned_alloc (C++17) calloc realloc free Gestión de memoria de bajo nivel operator new operator new[] operator delete operator delete[] get_new_handler set_new_handler bad_alloc bad_array_new_length nothrow_t align_val_t destroying_delete_t new_handler nothrow

 

std::shared_ptr

Funciones miembro

shared_ptr::shared_ptr

shared_ptr::~shared_ptr

shared_ptr::operator=

Modificadores

shared_ptr::reset

shared_ptr::swap

Observadores

shared_ptr::get

shared_ptr::operator*shared_ptr::operator->

shared_ptr::operator[] (C++17)

shared_ptr::use_count

shared_ptr::unique (hasta C++20)

shared_ptr::operator bool

shared_ptr::owner_before

Funciones no miembro

std::swap

make_sharedmake_shared_for_overwrite (C++20)

allocate_sharedallocate_shared_for_overwrite (C++20)

static_pointer_castdynamic_pointer_castconst_pointer_castreinterpret_pointer_cast (C++17)

get_deleter

operator==operator!=operator<operator<=operator>operator>=operator<=> (hasta C++20)(hasta C++20)(hasta C++20)(hasta C++20)(hasta C++20)(C++20)

operator<<

atomic_xxx functions (deprecated in C++20)

std::atomic<std::shared_ptr> (C++20)

std::hash

Guías de deducción(C++17)

 

template<class T > bool atomic_is_lock_free(conststd::shared_ptr<T>* p );	(1)	(desde C++11) (en desuso en C++20)
template<class T > std::shared_ptr<T> atomic_load(conststd::shared_ptr<T>* p );	(2)	(desde C++11) (en desuso en C++20)
template<class T > std::shared_ptr<T> atomic_load_explicit(conststd::shared_ptr<T>* p,                                          std::memory_order mo );	(3)	(desde C++11) (en desuso en C++20)
template<class T > void atomic_store(std::shared_ptr<T>* p,                    std::shared_ptr<T> r );	(4)	(desde C++11) (en desuso en C++20)
template<class T > void atomic_store_explicit(std::shared_ptr<T>* p,                             std::shared_ptr<T> r,                             std::memory_order mo);	(5)	(desde C++11) (en desuso en C++20)
template<class T > std::shared_ptr<T> atomic_exchange(std::shared_ptr<T>* p,                                     std::shared_ptr<T> r);	(6)	(desde C++11) (en desuso en C++20)
template<class T> std::shared_ptr<T> atomic_exchange_explicit(std::shared_ptr<T>* p,                                              std::shared_ptr<T> r,                                              std::memory_order mo);	(7)	(desde C++11) (en desuso en C++20)
template<class T > bool atomic_compare_exchange_weak(std::shared_ptr<T>* p,                                    std::shared_ptr<T>* expected,                                    std::shared_ptr<T> desired);	(8)	(desde C++11) (en desuso en C++20)
template<class T> bool atomic_compare_exchange_strong(std::shared_ptr<T>* p,                                      std::shared_ptr<T>* expected,                                      std::shared_ptr<T> desired);	(9)	(desde C++11) (en desuso en C++20)
template<class T > bool atomic_compare_exchange_strong_explicit(std::shared_ptr<T>* p,                                               std::shared_ptr<T>* expected,                                               std::shared_ptr<T> desired,                                               std::memory_order success,                                               std::memory_order failure);	(10)	(desde C++11) (en desuso en C++20)
template<class T > bool atomic_compare_exchange_weak_explicit(std::shared_ptr<T>* p,                                             std::shared_ptr<T>* expected,                                             std::shared_ptr<T> desired,                                             std::memory_order success,                                             std::memory_order failure);	(11)	(desde C++11) (en desuso en C++20)

Si varios hilos de ejecución acceden al mismo objeto std::shared_ptr sin sincronización y cualquiera de esos accesos utiliza una función de miembro no constante de shared_ptr, se producirá una carrera de datos a menos que todos esos accesos se realicen a través de estas funciones, que son sobrecargas de las funciones de acceso atómico correspondientes (std::atomic_load, std::atomic_store, etc.).

Tenga en cuenta que el bloque de control de shared_ptr es seguro para hilos: se puede acceder a diferentes objetos std::shared_ptr mediante operaciones mutables, como operator= o reset, simultáneamente por varios hilos, incluso cuando estas instancias son copias, y comparten el mismo bloque de control internamente.

1) Determina si el acceso atómico al puntero compartido al que apunta p está libre de bloqueo.

2) Equivalente a atomic_load_explicit(p, std::memory_order_seq_cst)

3) Devuelve el puntero compartido al que apunta p. Al igual que con la std::atomic_load_explicit no especializada, mo no puede ser std::memory_order_release o std::memory_order_acq_rel.

4) Equivalente a atomic_store_explicit(p, r, memory_order_seq_cst).

5) Almacena el puntero compartido r en el puntero compartido al que apunta p atómicamente. Efectivamente ejecuta p->swap(r). Al igual que con la std::atomic_store_explicit no especializada, mo no puede ser std::memory_order_acquire o std::memory_order_acq_rel.

6) Equivalente a atomic_exchange_explicit(p, r, memory_order_seq_cst).

7) Almacena el puntero compartido r en el puntero compartido al que apunta p y devuelve el valor al que p apuntaba anteriormente, atómicamente. Efectivamente ejecuta p->swap(r) y devuelve una copia de r después del intercambio.

8) Equivalente a atomic_compare_exchange_weak_explicit(p, expected, desired, std::memory_order_seq_cst, std::memory_order_seq_cst).

9) Equivalente a atomic_compare_exchange_strong_explicit(p, expected, desired, std::memory_order_seq_cst, std::memory_order_seq_cst).

10) Compara los punteros compartidos a los que apuntan p y expected. Si son equivalentes (almacenan el mismo valor de puntero y comparten la posesión del mismo objeto o ambos están vacíos), asigna desired a *p usando las restricciones de ordenamiento de memoria especificadas por success y devuelve true. Si no son equivalentes, asigna *p a *expected usando las restricciones de ordenamiento de memoria especificadas por failure y devuelve false.

11) Igual que (10), pero puede fallar espuriamente.

Todas estas funciones invocan un comportamiento no definido si p es un puntero nulo.

Parámetros

p, expected	-	Un puntero a un std::shared_ptr.
r, desired	-	Un std::shared_ptr.
mo, success, failure	-	Selectores de ordenamiento de memoria de tipo std::memory_order.

Excepciones

Estas funciones no lanzan excepciones.

Valor de retorno

1)true si el acceso atómico se implementa utilizando instrucciones libres de bloqueo.

2,3) Una copia del puntero compartido al que se apunta.

4,5) (Ninguno)

6,7) Una copia del puntero compartido al que se apuntaba anteriormente.

8,9,10,11)true si los punteros compartidos eran equivalentes y se realizó el intercambio, false de lo contrario.

Notas

Estas funciones generalmente se implementan mediante mutexes, almacenadas en una tabla de dispersión (hash) global donde el valor del puntero se usa como clave.

Para evitar carreras de datos, una vez que se pasa un puntero compartido a cualquiera de estas funciones, no se puede acceder a él de forma no atómica. En particular, no se puede desreferenciar tal shared_ptr sin primero cargarlo atómicamente en otro objeto shared_ptr y luego desreferenciarlo a través del segundo objeto.

La Especificación Técnica de Concurrencia ofrece clases de punteros inteligentes atómicos atomic_shared_ptr y atomic_weak_ptr como reemplazo para el uso de estas funciones.

Estas funciones quedaron obsoletas en favor de las especializaciones de la plantilla std::atomic: std::atomic<std::shared_ptr> y std::atomic<std::weak_ptr>.

(desde C++20)

Informes de defectos

Los siguientes informes de defectos de cambio de comportamiento se aplicaron de manera retroactiva a los estándares de C++ publicados anteriormente.

ID	Aplicado a	Comportamiento según lo publicado	Comportamiento correcto
LWG 2980	C++11	Los shared_ptr vacíos nunca son equivalentes.	Son equivalentes si almacenan el mismo valor de puntero.

Véase también

atomic_is_lock_free (C++11)	Comprueba si las operaciones del tipo atómico son sin bloqueo. (plantilla de función)
atomic_storeatomic_store_explicit (C++11)(C++11)	Sustituye atómicamente el valor del objeto atómico con el de un argumento no atómico. (plantilla de función)
atomic_loadatomic_load_explicit (C++11)(C++11)	Obtiene atómicamente el valor almacenado en un objeto atómico. (plantilla de función)
atomic_exchangeatomic_exchange_explicit (C++11)(C++11)	Reemplaza atómicamente el valor del objeto atómico con el del argumento no atómico y devuelve el valor anterior del objeto atómico. (plantilla de función)
atomic_compare_exchange_weakatomic_compare_exchange_weak_explicitatomic_compare_exchange_strongatomic_compare_exchange_strong_explicit (C++11)(C++11)(C++11)(C++11)	Compara atómicamente el valor del objeto atómico con el argumento no atómico y realiza un intercambio atómico si son iguales o una carga atómica si no lo son. (plantilla de función)