Namespaces
Variants

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

From cppreference.net
C++
Memory management library
( exposition only* )
Allocators
Uninitialized memory algorithms
Constrained uninitialized memory algorithms
Memory resources
Uninitialized storage (until C++20)
( until C++20* )
( until C++20* )
( until C++20* )

Garbage collector support (until C++23)
(C++11) (until C++23)
(C++11) (until C++23)
(C++11) (until C++23)
(C++11) (until C++23)
(C++11) (until C++23)
(C++11) (until C++23)
std::shared_ptr
Member functions
Modifiers
Observers
(C++17)
( until C++20* )
(C++26)
(C++26)
Non-member functions
(C++20)
(C++20)
(C++17)
(until C++20) (until C++20) (until C++20) (until C++20) (until C++20) (C++20)
atomic_xxx
functions ( until C++26* )
Helper classes
(C++20)
Deduction guides (C++17)
Definido en el encabezado <memory>
template < class T >
bool atomic_is_lock_free ( const std:: shared_ptr < T > * p ) ;
(1) (desde C++11)
(obsoleto en C++20)
(eliminado en C++26)
template < class T >
std:: shared_ptr < T > atomic_load ( const std:: shared_ptr < T > * p ) ;
(2) (desde C++11)
(obsoleto en C++20)
(eliminado en C++26)
template < class T >

std:: shared_ptr < T > atomic_load_explicit

( const std:: shared_ptr < T > * p, std:: memory_order mo ) ;
(3) (desde C++11)
(obsoleto en C++20)
(eliminado en C++26)
template < class T >
void atomic_store ( std:: shared_ptr < T > * p, std:: shared_ptr < T > r ) ;
(4) (desde C++11)
(obsoleto en C++20)
(eliminado en C++26)
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)
(obsoleto en C++20)
(eliminado en C++26)
template < class T >

std:: shared_ptr < T > atomic_exchange

( std:: shared_ptr < T > * p, std:: shared_ptr < T > r ) ;
(6) (desde C++11)
(obsoleto en C++20)
(eliminado en C++26)
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)
(obsoleto en C++20)
(eliminado en C++26)
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)
(obsoleto en C++20)
(eliminado en C++26)
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)
(obsoleto en C++20)
(eliminado en C++26)
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)
(obsoleto en C++20)
(eliminado en C++26)
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)
(obsoleto en C++20)
(eliminado en C++26)

Si múltiples hilos de ejecución acceden al mismo objeto std::shared_ptr sin sincronización y alguno de esos accesos utiliza una función miembro no constante de shared_ptr entonces ocurrirá una carrera de datos a menos que todo dicho acceso se realice 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 un shared_ptr es seguro para hilos: diferentes objetos std::shared_ptr pueden ser accedidos usando operaciones mutables, como operator = o reset , simultáneamente por múltiples hilos, incluso cuando estas instancias son copias y comparten internamente el mismo bloque de control.

1) Determina si el acceso atómico al puntero compartido apuntado por p es libre de bloqueo.
2) Equivalente a atomic_load_explicit ( p, std:: memory_order_seq_cst ) .
3) Devuelve el puntero compartido apuntado por p .
Al igual que con la versión no especializada std::atomic_load_explicit , si mo es std:: memory_order_release o std:: memory_order_acq_rel , el comportamiento es indefinido.
4) Equivalente a atomic_store_explicit ( p, r, std:: memory_order_seq_cst ) .
5) Almacena el puntero compartido r en el puntero compartido apuntado por p atómicamente, como si fuera mediante p - > swap ( r ) .
Al igual que con la versión no especializada std::atomic_store_explicit , si mo es std:: memory_order_acquire o std:: memory_order_acq_rel , el comportamiento es indefinido.
6) Equivalente a atomic_exchange_explicit ( p, r, std:: memory_order_seq_cst ) .
7) Almacena el puntero compartido r en el puntero compartido apuntado por p y devuelve el valor previamente apuntado por p , atómicamente, como si fuera mediante 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,11) Compara los punteros inteligentes apuntados por p y expected .
  • Si son equivalentes (almacenan el mismo valor de puntero, y comparten la propiedad del mismo objeto o ambos están vacíos), asigna desired en * p usando las restricciones de ordenamiento de memoria especificadas por success y retorna true .
  • Si no son equivalentes, asigna * p en * expected usando las restricciones de ordenamiento de memoria especificadas por failure y retorna false .
atomic_compare_exchange_weak_explicit puede fallar espuriamente.
Si expected es un puntero nulo, o failure es std:: memory_order_release o std:: memory_order_acq_rel , el comportamiento es indefinido.

Si p es un puntero nulo, el comportamiento de estas funciones es indefinido.

Contenidos

Parámetros

p, esperado - un puntero a un std::shared_ptr
r, deseado - un std::shared_ptr
mo, éxito, fallo - 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 lock-free.
2,3) Una copia del puntero compartido apuntado.
4,5) (ninguno)
6,7) Una copia del puntero compartido previamente apuntado.
8-11) true si los punteros compartidos eran equivalentes y el intercambio se realizó, false en caso contrario.

Notas

Estas funciones normalmente se implementan usando mutexes, almacenados en una tabla hash global donde el valor del puntero se utiliza como clave.

El Concurrency TS ofrece clases de punteros inteligentes atómicos atomic_shared_ptr y atomic_weak_ptr como reemplazo del uso de estas funciones.

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

(desde C++20)
(hasta C++26)

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

(desde C++26)

Ejemplo

Esta sección está incompleta
Razón: sin ejemplo

Informes de defectos

Los siguientes informes de defectos que modifican el comportamiento se aplicaron retroactivamente a los estándares publicados anteriormente de C++.

DR Se aplica a Comportamiento publicado Comportamiento correcto
LWG 2172 C++11 expected podría ser un puntero nulo el comportamiento no está definido en este caso
LWG 2980 C++11 los shared_ptr vacíos nunca eran equivalentes equivalentes si almacenan el mismo valor de puntero

Véase también

(C++11)
verifica si las operaciones del tipo atómico son libres de bloqueo
(plantilla de función)
(C++11) (C++11)
reemplaza atómicamente el valor del objeto atómico con un argumento no atómico
(plantilla de función)
(C++11) (C++11)
obtiene atómicamente el valor almacenado en un objeto atómico
(plantilla de función)
(C++11) (C++11)
reemplaza atómicamente el valor del objeto atómico con un argumento no atómico y devuelve el valor antiguo del atómico
(plantilla de función)
(C++11) (C++11) (C++11) (C++11)
compara atómicamente el valor del objeto atómico con un 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)