std::atomic_ref

 

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 operaciones atómicas

Tipos

atomic (C++11)

atomic_ref (C++20)

Funciones

atomic_storeatomic_store_explicit (C++11)(C++11)

atomic_loadatomic_load_explicit (C++11)(C++11)

atomic_exchangeatomic_exchange_explicit (C++11)(C++11)

atomic_compare_exchange_weakatomic_compare_exchange_weak_explicitatomic_compare_exchange_strongatomic_compare_exchange_strong_explicit (C++11)(C++11)(C++11)(C++11)

atomic_fetch_addatomic_fetch_add_explicit (C++11)(C++11)

atomic_fetch_subatomic_fetch_sub_explicit (C++11)(C++11)

atomic_fetch_andatomic_fetch_and_explicit (C++11)(C++11)

atomic_fetch_oratomic_fetch_or_explicit (C++11)(C++11)

atomic_fetch_xoratomic_fetch_xor_explicit (C++11)(C++11)

atomic_is_lock_free (C++11)

atomic_waitatomic_wait_explicit (C++20)(C++20)

atomic_notify_one (C++20)

atomic_notify_all (C++20)

Banderas atómicas

atomic_flag (C++11)

atomic_flag_test_and_setatomic_flag_test_and_set_explicit (C++11)(C++11)

atomic_flag_clearatomic_flag_clear_explicit (C++11)(C++11)

atomic_flag_testatomic_flag_test_explicit (C++20)(C++20)

atomic_flag_waitatomic_flag_wait_explicit (C++20)(C++20)

atomic_flag_notify_one (C++20)

atomic_flag_notify_all (C++20)

Inicialización

atomic_init (C++11)(en desuso en C++20)

ATOMIC_VAR_INIT (C++11)(en desuso en C++20)

ATOMIC_FLAG_INIT (C++11)(en desuso en C++20)

Ordenamiento de memoria

memory_order (C++11)

kill_dependency (C++11)

atomic_thread_fence (C++11)

atomic_signal_fence (C++11)

 

std::atomic_ref

Funciones miembro

atomic_ref::atomic_ref

atomic_ref::operator=

atomic_ref::is_lock_free

atomic_ref::store

atomic_ref::load

atomic_ref::operator T

atomic_ref::exchange

atomic_ref::compare_exchange_strongatomic_ref::compare_exchange_weak

atomic_ref::wait (C++20)

atomic_ref::notify_one (C++20)

atomic_ref::notify_all (C++20)

Constantes

atomic_ref::is_always_lock_free

atomic_ref::required_alignment

Funciones miembro especializadas

atomic_ref::fetch_add

atomic_ref::fetch_sub

atomic_ref::fetch_and

atomic_ref::fetch_or

atomic_ref::fetch_xor

atomic_ref::operator++atomic_ref::operator++(int)atomic_ref::operator--atomic_ref::operator--(int)

atomic_ref::operator+=atomic_ref::operator-=atomic_ref::operator&=atomic_ref::operator|=atomic_ref::operator^=

 

Definido en el archivo de encabezado <atomic>
template<class T > struct atomic_ref;	(1)	(desde C++20)
template<class T > struct atomic_ref<T*>;	(2)	(desde C++20)

La plantilla de clase referencia atómica,std::atomic_ref, aplica operaciones atómicas al objeto al que hace referencia. Durante el tiempo de vida del objeto atomic_ref, el objeto al que se hace referencia se considera un objeto atómico. Si un hilo escribe a un objeto atómico mientras otro hilo lee de él, el comportamiento está bien definido (véase modelo de memoria para detalles sobre carreras de datos). Además, accesos a objetos atómicos pueden establecer sincronización intrahilos y ordenar accesos a memoria no atómicos como se especifica en std::memory_order.

El tiempo de vida de un objeto debe exceder el tiempo de vida de todas las referencias atómicas que hacen referencia al objeto. Siempre y cuando existan instancias atomic_ref que hagan referencia a un objeto, tal objeto debe accederse exclusivamente a través de estas instancias. Ningún subobjeto al que se hace referencia mediante una referencia atómica puede hacerse referencia concurrentemente por otra referencia atómica.

Las operaciones atómicas aplicadas a un objeto a través de una referencia atómica son atómicas con respecto a las operaciones atómicas aplicadas a través de cualquier otra referencia atómica que hacen referencia al mismo objeto.

std::atomic_ref es CopyConstructible.

De manera similar a las referencias del lenguaje C++, la constantitud de atomic_ref es superficial. Es posible modificar el valor referenciado a través de un objeto constatomic_ref.

Especializaciones

Plantilla primaria

La plantilla primaria std::atomic_ref puede instanciarse con cualquier tipo TTriviallyCopyable (incluyendo bool):

struct Contadores {int a;int b;} contador;// tipo trivialmente copiable definido por el usuario std::atomic_ref<Contadores> cnt(contador);// especialización para el tipo definido por el usuario

Especialización parcial para tipos puntero

La biblioteca estándar proporciona especializaciones parciales de la plantilla std::atomic_ref para todos los tipos puntero. Además de las operaciones proporcionadas para todos los tipos atómicos, estas especializaciones soportan adicionalmente operaciones atómicas aritméticas apropiadas para los tipos punteros, tales como fetch_add y fetch_sub.

Especializaciones para tipos enteros

Al instanciarse con cualquiera de los siguientes tipos enteros, std::atomic_ref proporciona operaciones atómicas adicionales apropiadas para los tipos enteros, tales como fetch_add, fetch_sub, fetch_and, fetch_or y fetch_xor:

• Los tipos carácter char, char8_t, char16_t, char32_t, y wchar_t;
• Los tipos estándar enteros con signo: signedchar, short, int, long, y longlong;
• Los tipos estándar enteros sin signo: unsignedchar, unsignedshort, unsignedint, unsignedlong, y unsignedlonglong;
• Cualquier tipo adicional entero que se necesita por las definiciones de tipo (typedef) en el archivo de encabezado <cstdint>.

La aritmética de enteros con signo usa complemento a dos; no existen resultados indefinidos.

Especializaciones para tipos de punto flotante

Al instanciarse con uno de los tipos de punto flotante float, double, y longdouble, std::atomic_ref proporciona operaciones atómicas adicionales apropiadas para tipos flotantes, tales como fetch_add y fetch_sub.

Ninguna operación resulta en comportamiento indefinido incluso si el resultado no es representable en el tipo de punto flotante. El entorno de punto flotante en efecto puede ser diferente del entorno de punto flotante del hilo que efectúa la llamada.

Tipos miembro

Tipo miembro	Definición
value_type	véase abajo
difference_type	value_type(Solo para especializaciones atomic_ref<Entero> y atomic_ref<Flotante>) std::ptrdiff_t(Solo para especializaciones atomic_ref<T*>)

Para cada std::atomic_ref<X> (esté especializada o no), std::atomic_ref<X>::value_type es X.

difference_type no está definido en la plantilla primaria atomic_ref.

Funciones miembro

(constructor)	Construye un objeto atomic_ref. (función miembro pública)
operator=	Almacena un valor en un objeto al que se hace referencia por un objeto atomic_ref. (función miembro pública)
is_lock_free	Comprueba si el objeto atomic_ref está libre de bloqueos. (función miembro pública)
store	Reemplaza atómicamente el valor del objeto al que se hace referencia con un argumento no atómico. (función miembro pública)
load	Obtiene atómicamente el valor del objeto al que se hace referencia. (función miembro pública)
operator T	Carga un valor desde el objeto al que se hace referencia. (función miembro pública)
exchange	Reemplaza atómicamente el valor del objeto al que se hace referencia y obtiene el valor previamente albergado. (función miembro pública)
compare_exchange_weakcompare_exchange_strong	Compara atómicamente el valor del objeto al que se hace referencia con el argumento no atómico y realiza un intercambio atómico si son iguales, o una carga atómica si no lo son. (función miembro pública)
wait (C++20)	Bloquea el hilo hasta que se notifique y el valor atómico cambie. (función miembro pública)
notify_one (C++20)	Notifica al menos a un hilo/subproceso esperando al objeto atómico. (función miembro pública)
notify_all (C++20)	Notifica a todos los hilos/subprocesos bloqueados esperando al objeto atómico. (función miembro pública)
Constantes
is_always_lock_free [estático]	Indica que el tipo siempre está libre de bloqueos. (constante miembro pública estática)
required_alignment [estático]	Indica la alineación requerida de un objeto a que se va a hacer referencia por atomic_ref. (constante miembro pública estática)

Funciones miembro especializadas

fetch_add	Suma atómicamente el argumento al valor almacenado en el objeto al que se hace referencia y obtiene el valor previamente albergado. (función miembro pública)
fetch_sub	Resta atómicamente el argumento del valor almacenado en el objeto al que se hace referencia y obtiene el valor previamente albergado. (función miembro pública)
fetch_and	Realiza atómicamente una operación AND de bits entre el argumento y el valor del objeto al que se hace referencia y obtiene el valor previamente albergado. (función miembro pública)
fetch_or	Realiza atómicamente una operación OR de bits entre el argumento y el valor del objeto al que se hace referencia y obtiene el valor previamente albergado. (función miembro pública)
fetch_xor	Realiza atómicamente una operación XOR de bits entre el argumento y el valor del objeto al que se hace referencia y obtiene el valor previamente albergado. (función miembro pública)
operator++operator++(int)operator--operator--(int)	Atómicamente incrementa o decrementa el objeto al que se hace referencia en uno. (función miembro pública)
operator+=operator-=operator&=operator|=operator^=	Atómicamente suma, resta o realiza una operación de bits AND, OR o XOR con el valor al que se hace referencia. (función miembro pública)

Véase también

atomic (C++11)

Plantilla de clase atómica y especializaciones para los tipos bool, enteros y tipos puntero. (plantilla de clase)