Namespaces
Variants

std:: atomic <std::weak_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::weak_ptr
Definido en el encabezado <memory>
template < class T > struct std:: atomic < std:: weak_ptr < T >> ;
(desde C++20)

La especialización parcial de plantilla de std::atomic para std:: weak_ptr < T > permite a los usuarios manipular objetos weak_ptr atómicamente.

Si múltiples hilos de ejecución acceden al mismo std::weak_ptr sin sincronización y cualquiera de esos accesos utiliza una función miembro no constante de weak_ptr entonces ocurrirá una carrera de datos a menos que todo dicho acceso se realice a través de una instancia de std:: atomic < std:: weak_ptr > .

Los incrementos asociados de use_count están garantizados como parte de la operación atómica. Los decrementos asociados de use_count se secuencian después de la operación atómica, pero no se requieren como parte de ella, excepto para el cambio de use_count al sobrescribir expected en un CAS fallido. Cualquier eliminación y desasignación asociada se secuencian después del paso de actualización atómica y no forman parte de la operación atómica.

Tenga en cuenta que el bloque de control utilizado por std::weak_ptr y std::shared_ptr es seguro para hilos: diferentes objetos std::weak_ptr no atómicos pueden ser accedidos mediante operaciones mutables, como operator = o reset , simultáneamente por múltiples hilos, incluso cuando estas instancias son copias o comparten internamente el mismo bloque de control.

El tipo T puede ser un tipo incompleto.

Contenidos

Tipos de miembros

Tipo de miembro Definición
value_type std:: weak_ptr < T >

Funciones miembro

Todas las funciones no especializadas de std::atomic también están proporcionadas por esta especialización, y no hay funciones miembro adicionales.

atomic<weak_ptr<T>>:: atomic

constexpr atomic ( ) noexcept = default ;
(1)
atomic ( std:: weak_ptr < T > desired ) noexcept ;
(2)
atomic ( const atomic & ) = delete ;
(3)
1) Inicializa el weak_ptr<T> subyacente con el valor construido por defecto.
2) Inicializa el weak_ptr<T> subyacente con una copia de desired . Como con cualquier tipo std::atomic , la inicialización no es una operación atómica.
3) Los tipos atómicos no son copiables/movibles.

atomic<weak_ptr<T>>:: operator=

void operator = ( const atomic & ) = delete ;
(1)
void operator = ( std:: weak_ptr < T > desired ) noexcept ;
(2)
1) Los tipos atómicos no son asignables por copia/movimiento.
2) Asignación de valor, equivalente a store ( desired ) .

atomic<weak_ptr<T>>:: is_lock_free

bool is_lock_free ( ) const noexcept ;

Devuelve true si las operaciones atómicas en todos los objetos de este tipo son libres de bloqueo, false en caso contrario.

atomic<weak_ptr<T>>:: store

void store ( std:: weak_ptr < T > desired,
std:: memory_order order = std:: memory_order_seq_cst ) noexcept ;

Reemplaza atómicamente el valor de * this con el valor de desired como si fuera mediante p. swap ( desired ) donde p es el std:: weak_ptr < T > subyacente. La memoria se ordena según order . El comportamiento es indefinido si order es std::memory_order_consume , std::memory_order_acquire , o std::memory_order_acq_rel .

atomic<weak_ptr<T>>:: load

Devuelve atómicamente una copia del std:: weak_ptr < T > subyacente. La memoria se ordena según order . El comportamiento es indefinido si order es std::memory_order_release o std::memory_order_acq_rel .

atomic<weak_ptr<T>>:: operator std::weak_ptr<T>

operator std:: weak_ptr < T > ( ) const noexcept ;

Equivalente a return load ( ) ; .

atomic<weak_ptr<T>>:: exchange

Reemplaza atómicamente el std:: weak_ptr < T > subyacente con desired como si se hiciera mediante p. swap ( desired ) donde p es el std:: weak_ptr < T > subyacente, y devuelve una copia del valor que p tenía inmediatamente antes del intercambio. La memoria se ordena según order . Esta es una operación atómica de lectura-modificación-escritura.

atomic<weak_ptr<T>>:: compare_exchange_weak, compare_exchange_strong

bool compare_exchange_strong ( std:: weak_ptr < T > & expected, std:: weak_ptr < T > desired,
std:: memory_order success, std:: memory_order failure ) noexcept ;
(1)
bool compare_exchange_weak ( std:: weak_ptr < T > & expected, std:: weak_ptr < T > desired,
std:: memory_order success, std:: memory_order failure ) noexcept ;
(2)
bool compare_exchange_strong ( std:: weak_ptr < T > & expected, std:: weak_ptr < T > desired,
std:: memory_order order = std:: memory_order_seq_cst ) noexcept ;
(3)
bool compare_exchange_weak ( std:: weak_ptr < T > & expected, std:: weak_ptr < T > desired,
std:: memory_order order = std:: memory_order_seq_cst ) noexcept ;
(4)
1) Si el subyacente std:: weak_ptr < T > almacena el mismo valor de puntero que expected y comparte propiedad con él, o si tanto el subyacente como expected están vacíos, asigna desde desired al subyacente std:: weak_ptr < T > , retorna true , y ordena la memoria de acuerdo con success ; de lo contrario asigna desde el subyacente std:: weak_ptr < T > a expected , retorna false , y ordena la memoria de acuerdo con failure . El comportamiento es indefinido si failure es std::memory_order_release o std::memory_order_acq_rel . En caso de éxito, la operación es una operación atómica de lectura-modificación-escritura en * this y expected no se accede después de la actualización atómica. En caso de fallo, la operación es una operación atómica de carga en * this y expected se actualiza con el valor existente leído del objeto atómico. Esta actualización del use_count de expected es parte de esta operación atómica, aunque la escritura en sí misma (y cualquier desalocación/destrucción posterior) no está requerida que lo sea.
2) Igual que (1) , pero también puede fallar espuriamente.
3) Equivalente a: return compare_exchange_strong ( expected, desired, order, fail_order ) ; , donde fail_order es el mismo que order excepto que std::memory_order_acq_rel es reemplazado por std::memory_order_acquire y std::memory_order_release es reemplazado por std::memory_order_relaxed .
4) Equivalente a: return compare_exchange_weak ( expected, desired, order, fail_order ) ; , donde fail_order es igual que order excepto que std::memory_order_acq_rel se reemplaza por std::memory_order_acquire y std::memory_order_release se reemplaza por std::memory_order_relaxed .

atomic<weak_ptr<T>>:: wait

void wait ( std:: weak_ptr < T > old
std:: memory_order order = std:: memory_order_seq_cst ) const noexcept ;

Realiza una operación de espera atómica.

Compara load ( order ) con old y si son equivalentes, se bloquea hasta que * this sea notificado por notify_one() o notify_all() . Esto se repite hasta que load ( order ) cambie. Esta función garantiza que solo retornará si el valor ha cambiado, incluso si la implementación subyacente se desbloquea espuriamente.

La memoria se ordena de acuerdo con order . El comportamiento es indefinido si order es std::memory_order_release o std::memory_order_acq_rel .

Notas: dos std::weak_ptr son equivalentes si almacenan el mismo puntero y comparten la propiedad o ambos están vacíos.

atomic<weak_ptr<T>>:: notify_one

void notify_one ( ) noexcept ;

Realiza una operación de notificación atómica.

Si hay un hilo bloqueado en operaciones de espera atómica (es decir, wait() ) en * this , entonces desbloquea al menos uno de dichos hilos; de lo contrario no hace nada.

atomic<weak_ptr<T>>:: notify_all

void notify_all ( ) noexcept ;

Realiza una operación de notificación atómica.

Desbloquea todos los hilos bloqueados en operaciones de espera atómica (es decir, wait() ) en * this , si los hay; de lo contrario no hace nada.

Constantes de miembro

La única constante miembro estándar std::atomic is_always_lock_free también es proporcionada por esta especialización.

atomic<weak_ptr<T>>:: is_always_lock_free

static constexpr bool is_always_lock_free = /*implementation-defined*/ ;

Ejemplo

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

Véase también

(C++11)
Plantilla de clase atomic y especializaciones para bool, tipos integrales, tipos de punto flotante, (desde C++20) y tipos puntero
(plantilla de clase)