Archivo de encabezado de la biblioteca estándar <atomic>
De cppreference.com
Este archivo de encabezado es parte de la biblioteca de operaciones atómicas.
Clases | |
(C++11) |
Plantilla de clase atómica y especializaciones para los tipos bool, enteros y tipos puntero. (plantilla de clase) |
(C++20) |
Proporciona operaciones atómicas en objetos no atómicos. (plantilla de clase) |
(C++11) |
El tipo atómico booleano libre de bloqueo. (clase) |
(C++11) |
Define las restricciones del ordenamiento de memoria para la operación atómica dada. (typedef) |
Definiciones de tipos | |
std::atomic_bool
|
std::atomic<bool>
|
std::atomic_char
|
std::atomic<char>
|
std::atomic_schar
|
std::atomic<signed char>
|
std::atomic_uchar
|
std::atomic<unsigned char>
|
std::atomic_short
|
std::atomic<short>
|
std::atomic_ushort
|
std::atomic<unsigned short>
|
std::atomic_int
|
std::atomic<int>
|
std::atomic_uint
|
std::atomic<unsigned int>
|
std::atomic_long
|
std::atomic<long>
|
std::atomic_ulong
|
std::atomic<unsigned long>
|
std::atomic_llong
|
std::atomic<long long>
|
std::atomic_ullong
|
std::atomic<unsigned long long>
|
std::atomic_char8_t (C++20)
|
std::atomic<char8_t>
|
std::atomic_char16_t
|
std::atomic<char16_t>
|
std::atomic_char32_t
|
std::atomic<char32_t>
|
std::atomic_wchar_t
|
std::atomic<wchar_t>
|
std::atomic_int8_t
|
std::atomic<std::int8_t>
|
std::atomic_uint8_t
|
std::atomic<std::uint8_t>
|
std::atomic_int16_t
|
std::atomic<std::int16_t>
|
std::atomic_uint16_t
|
std::atomic<std::uint16_t>
|
std::atomic_int32_t
|
std::atomic<std::int32_t>
|
std::atomic_uint32_t
|
std::atomic<std::uint32_t>
|
std::atomic_int64_t
|
std::atomic<std::int64_t>
|
std::atomic_uint64_t
|
std::atomic<std::uint64_t>
|
std::atomic_int_least8_t
|
std::atomic<int_least8_t>
|
std::atomic_uint_least8_t
|
std::atomic<uint_least8_t>
|
std::atomic_int_least16_t
|
std::atomic<int_least16_t>
|
std::atomic_uint_least16_t
|
std::atomic<uint_least16_t>
|
std::atomic_int_least32_t
|
std::atomic<int_least32_t>
|
std::atomic_uint_least32_t
|
std::atomic<uint_least32_t>
|
std::atomic_int_least64_t
|
std::atomic<int_least64_t>
|
std::atomic_uint_least64_t
|
std::atomic<uint_least64_t>
|
std::atomic_int_fast8_t
|
std::atomic<int_fast8_t>
|
std::atomic_uint_fast8_t
|
std::atomic<uint_fast8_t>
|
std::atomic_int_fast16_t
|
std::atomic<int_fast16_t>
|
std::atomic_uint_fast16_t
|
std::atomic<uint_fast16_t>
|
std::atomic_int_fast32_t
|
std::atomic<int_fast32_t>
|
std::atomic_uint_fast32_t
|
std::atomic<uint_fast32_t>
|
std::atomic_int_fast64_t
|
std::atomic<int_fast64_t>
|
std::atomic_uint_fast64_t
|
std::atomic<uint_fast64_t>
|
std::atomic_intptr_t
|
std::atomic<intptr_t>
|
std::atomic_uintptr_t
|
std::atomic<uintptr_t>
|
std::atomic_size_t
|
std::atomic<size_t>
|
std::atomic_ptrdiff_t
|
std::atomic<ptrdiff_t>
|
std::atomic_intmax_t
|
std::atomic<intmax_t>
|
std::atomic_uintmax_t
|
std::atomic<uintmax_t>
|
std::atomic_signed_lock_free (C++20)
|
Un tipo atómico entero con signo que es sin bloqueo y por el cual la espera/notificación es más eficiente. |
std::atomic_unsigned_lock_free (C++20)
|
Un tipo atómico entero sin signo que es sin bloqueo y por el cual la espera/notificación es más eficiente. |
Funciones | |
(C++11) |
Comprueba si las operaciones del tipo atómico son sin bloqueo. (plantilla de función) |
(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) |
(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 el del argumento no atómico y devuelve el valor anterior del objeto atómico. (plantilla de función) |
| 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) | |
(C++11)(C++11) |
Agrega un valor no atómico a un objeto atómico y obtiene el valor anterior del objeto atómico. (plantilla de función) |
(C++11)(C++11) |
Resta un valor no atómico de un objeto atómico y obtiene el valor anterior del objeto atómico. (plantilla de función) |
(C++11)(C++11) |
Reemplaza el objeto atómico con el resultado de la operación lógica AND con un argumento no atómico y obtiene el valor anterior del objeto atómico. (plantilla de función) |
(C++11)(C++11) |
Reemplaza el objeto atómico con el resultado de la operación lógica OR con un argumento no atómico y obtiene el valor anterior del objeto atómico. (plantilla de función) |
(C++11)(C++11) |
Reemplaza el objeto atómico con el resultado de la operación lógica XOR con un argumento no atómico y obtiene el valor anterior del objeto atómico. (plantilla de función) |
(C++20)(C++20) |
Bloquea el hilo/subproceso hasta que se reciba una notificación y el valor atómico cambie. (plantilla de función) |
(C++20) |
Notifica a un hilo bloqueado en atomic_wait. (plantilla de función) |
(C++20) |
Notifica a todos los hilos bloqueados en atomic_wait. (plantilla de función) |
(C++20)(C++20) |
Devuelve atómicamente el valor de la bandera. (función) |
Establece atómicamente la bandera a true y devuelve su valor anterior. (función) | |
(C++11)(C++11) |
Establece atómicamente el valor de la bandera a false. (función) |
(C++20)(C++20) |
Bloquea el hilo/subproceso hasta que haya una notificación y la bandera cambie. (función) |
(C++20) |
Notifica a un hilo bloqueado en atomic_flag_wait. (función) |
(C++20) |
Notifica a todos los hilos bloqueados en atomic_flag_wait. (función) |
(C++11)(en desuso en C++20) |
Inicialización no atómica de un objeto atómico construido por defecto. (plantilla de función) |
(C++11) |
Quita el objeto especificado del árbol de dependencias de std::memory_order_consume. (plantilla de función) |
(C++11) |
Primitiva de sincronización de barrera genérica de memoria dependiente del orden. (función) |
(C++11) |
Barrera entre un hilo y un controlador de señales ejecutados en el mismo hilo/subproceso. (función) |
Macros de preprocesador | |
(C++11) |
Inicialización por constante de una variable atómica de duración de almacenamiento estática. (macro de función) |
(C++11) |
Inicializa una bandera std::atomic_flag a false. (constante de macro) |
Sinopsis
namespace std {
/* hasta C++20:
typedef enum memory_order {
memory_order_relaxed,
memory_order_consume,
memory_order_acquire,
memory_order_release,
memory_order_acq_rel,
memory_order_seq_cst
} memory_order;
*/
enum class memory_order : /* sin especificar */ {
relaxed, consume, acquire, release, acq_rel, seq_cst
};
inline constexpr memory_order memory_order_relaxed = memory_order::relaxed;
inline constexpr memory_order memory_order_consume = memory_order::consume;
inline constexpr memory_order memory_order_acquire = memory_order::acquire;
inline constexpr memory_order memory_order_release = memory_order::release;
inline constexpr memory_order memory_order_acq_rel = memory_order::acq_rel;
inline constexpr memory_order memory_order_seq_cst = memory_order::seq_cst;
template<class T>
T kill_dependency(T y) noexcept;
// propiedad sin bloqueo
#define ATOMIC_BOOL_LOCK_FREE /* sin especificar */
#define ATOMIC_CHAR_LOCK_FREE /* sin especificar */
#define ATOMIC_CHAR8_T_LOCK_FREE /* sin especificar */
#define ATOMIC_CHAR16_T_LOCK_FREE /* sin especificar */
#define ATOMIC_CHAR32_T_LOCK_FREE /* sin especificar */
#define ATOMIC_WCHAR_T_LOCK_FREE /* sin especificar */
#define ATOMIC_SHORT_LOCK_FREE /* sin especificar */
#define ATOMIC_INT_LOCK_FREE /* sin especificar */
#define ATOMIC_LONG_LOCK_FREE /* sin especificar */
#define ATOMIC_LLONG_LOCK_FREE /* sin especificar */
#define ATOMIC_POINTER_LOCK_FREE /* sin especificar */
// plantilla de clase atomic_ref
template<class T> struct atomic_ref;
// especialización parcial para punteros
template<class T> struct atomic_ref<T*>;
// plantilla de clase atomic
template<class T> struct atomic;
// especialización parcial para punteros
template<class T> struct atomic<T*>;
// funciones no miembro
template<class T>
bool atomic_is_lock_free(const volatile atomic<T>*) noexcept;
template<class T>
bool atomic_is_lock_free(const atomic<T>*) noexcept;
template<class T>
void atomic_store(volatile atomic<T>*, typename atomic<T>::value_type) noexcept;
template<class T>
void atomic_store(atomic<T>*, typename atomic<T>::value_type) noexcept;
template<class T>
void atomic_store_explicit(volatile atomic<T>*, typename atomic<T>::value_type,
memory_order) noexcept;
template<class T>
void atomic_store_explicit(atomic<T>*, typename atomic<T>::value_type,
memory_order) noexcept;
template<class T>
T atomic_load(const volatile atomic<T>*) noexcept;
template<class T>
T atomic_load(const atomic<T>*) noexcept;
template<class T>
T atomic_load_explicit(const volatile atomic<T>*, memory_order) noexcept;
template<class T>
T atomic_load_explicit(const atomic<T>*, memory_order) noexcept;
template<class T>
T atomic_exchange(volatile atomic<T>*, typename atomic<T>::value_type) noexcept;
template<class T>
T atomic_exchange(atomic<T>*, typename atomic<T>::value_type) noexcept;
template<class T>
T atomic_exchange_explicit(volatile atomic<T>*, typename atomic<T>::value_type,
memory_order) noexcept;
template<class T>
T atomic_exchange_explicit(atomic<T>*, typename atomic<T>::value_type,
memory_order) noexcept;
template<class T>
bool atomic_compare_exchange_weak(volatile atomic<T>*,
typename atomic<T>::value_type*,
typename atomic<T>::value_type) noexcept;
template<class T>
bool atomic_compare_exchange_weak(atomic<T>*,
typename atomic<T>::value_type*,
typename atomic<T>::value_type) noexcept;
template<class T>
bool atomic_compare_exchange_strong(volatile atomic<T>*,
typename atomic<T>::value_type*,
typename atomic<T>::value_type) noexcept;
template<class T>
bool atomic_compare_exchange_strong(atomic<T>*,
typename atomic<T>::value_type*,
typename atomic<T>::value_type) noexcept;
template<class T>
bool atomic_compare_exchange_weak_explicit(volatile atomic<T>*,
typename atomic<T>::value_type*,
typename atomic<T>::value_type,
memory_order, memory_order) noexcept;
template<class T>
bool atomic_compare_exchange_weak_explicit(atomic<T>*,
typename atomic<T>::value_type*,
typename atomic<T>::value_type,
memory_order, memory_order) noexcept;
template<class T>
bool atomic_compare_exchange_strong_explicit(volatile atomic<T>*,
typename atomic<T>::value_type*,
typename atomic<T>::value_type,
memory_order, memory_order) noexcept;
template<class T>
bool atomic_compare_exchange_strong_explicit(atomic<T>*,
typename atomic<T>::value_type*,
typename atomic<T>::value_type,
memory_order, memory_order) noexcept;
template<class T>
T atomic_fetch_add(volatile atomic<T>*, typename atomic<T>::difference_type) noexcept;
template<class T>
T atomic_fetch_add(atomic<T>*, typename atomic<T>::difference_type) noexcept;
template<class T>
T atomic_fetch_add_explicit(volatile atomic<T>*, typename atomic<T>::difference_type,
memory_order) noexcept;
template<class T>
T atomic_fetch_add_explicit(atomic<T>*, typename atomic<T>::difference_type,
memory_order) noexcept;
template<class T>
T atomic_fetch_sub(volatile atomic<T>*, typename atomic<T>::difference_type) noexcept;
template<class T>
T atomic_fetch_sub(atomic<T>*, typename atomic<T>::difference_type) noexcept;
template<class T>
T atomic_fetch_sub_explicit(volatile atomic<T>*, typename atomic<T>::difference_type,
memory_order) noexcept;
template<class T>
T atomic_fetch_sub_explicit(atomic<T>*, typename atomic<T>::difference_type,
memory_order) noexcept;
template<class T>
T atomic_fetch_and(volatile atomic<T>*, typename atomic<T>::value_type) noexcept;
template<class T>
T atomic_fetch_and(atomic<T>*, typename atomic<T>::value_type) noexcept;
template<class T>
T atomic_fetch_and_explicit(volatile atomic<T>*, typename atomic<T>::value_type,
memory_order) noexcept;
template<class T>
T atomic_fetch_and_explicit(atomic<T>*, typename atomic<T>::value_type,
memory_order) noexcept;
template<class T>
T atomic_fetch_or(volatile atomic<T>*, typename atomic<T>::value_type) noexcept;
template<class T>
T atomic_fetch_or(atomic<T>*, typename atomic<T>::value_type) noexcept;
template<class T>
T atomic_fetch_or_explicit(volatile atomic<T>*, typename atomic<T>::value_type,
memory_order) noexcept;
template<class T>
T atomic_fetch_or_explicit(atomic<T>*, typename atomic<T>::value_type,
memory_order) noexcept;
template<class T>
T atomic_fetch_xor(volatile atomic<T>*, typename atomic<T>::value_type) noexcept;
template<class T>
T atomic_fetch_xor(atomic<T>*, typename atomic<T>::value_type) noexcept;
template<class T>
T atomic_fetch_xor_explicit(volatile atomic<T>*, typename atomic<T>::value_type,
memory_order) noexcept;
template<class T>
T atomic_fetch_xor_explicit(atomic<T>*, typename atomic<T>::value_type,
memory_order) noexcept;
template<class T>
void atomic_wait(const volatile atomic<T>*, typename atomic<T>::value_type);
template<class T>
void atomic_wait(const atomic<T>*, typename atomic<T>::value_type);
template<class T>
void atomic_wait_explicit(const volatile atomic<T>*, typename atomic<T>::value_type,
memory_order);
template<class T>
void atomic_wait_explicit(const atomic<T>*, typename atomic<T>::value_type,
memory_order);
template<class T>
void atomic_notify_one(volatile atomic<T>*);
template<class T>
void atomic_notify_one(atomic<T>*);
template<class T>
void atomic_notify_all(volatile atomic<T>*);
template<class T>
void atomic_notify_all(atomic<T>*);
// alias de tipos
using atomic_bool = atomic<bool>;
using atomic_char = atomic<char>;
using atomic_schar = atomic<signed char>;
using atomic_uchar = atomic<unsigned char>;
using atomic_short = atomic<short>;
using atomic_ushort = atomic<unsigned short>;
using atomic_int = atomic<int>;
using atomic_uint = atomic<unsigned int>;
using atomic_long = atomic<long>;
using atomic_ulong = atomic<unsigned long>;
using atomic_llong = atomic<long long>;
using atomic_ullong = atomic<unsigned long long>;
using atomic_char8_t = atomic<char8_t>;
using atomic_char16_t = atomic<char16_t>;
using atomic_char32_t = atomic<char32_t>;
using atomic_wchar_t = atomic<wchar_t>;
using atomic_int8_t = atomic<int8_t>;
using atomic_uint8_t = atomic<uint8_t>;
using atomic_int16_t = atomic<int16_t>;
using atomic_uint16_t = atomic<uint16_t>;
using atomic_int32_t = atomic<int32_t>;
using atomic_uint32_t = atomic<uint32_t>;
using atomic_int64_t = atomic<int64_t>;
using atomic_uint64_t = atomic<uint64_t>;
using atomic_int_least8_t = atomic<int_least8_t>;
using atomic_uint_least8_t = atomic<uint_least8_t>;
using atomic_int_least16_t = atomic<int_least16_t>;
using atomic_uint_least16_t = atomic<uint_least16_t>;
using atomic_int_least32_t = atomic<int_least32_t>;
using atomic_uint_least32_t = atomic<uint_least32_t>;
using atomic_int_least64_t = atomic<int_least64_t>;
using atomic_uint_least64_t = atomic<uint_least64_t>;
using atomic_int_fast8_t = atomic<int_fast8_t>;
using atomic_uint_fast8_t = atomic<uint_fast8_t>;
using atomic_int_fast16_t = atomic<int_fast16_t>;
using atomic_uint_fast16_t = atomic<uint_fast16_t>;
using atomic_int_fast32_t = atomic<int_fast32_t>;
using atomic_uint_fast32_t = atomic<uint_fast32_t>;
using atomic_int_fast64_t = atomic<int_fast64_t>;
using atomic_uint_fast64_t = atomic<uint_fast64_t>;
using atomic_intptr_t = atomic<intptr_t>;
using atomic_uintptr_t = atomic<uintptr_t>;
using atomic_size_t = atomic<size_t>;
using atomic_ptrdiff_t = atomic<ptrdiff_t>;
using atomic_intmax_t = atomic<intmax_t>;
using atomic_uintmax_t = atomic<uintmax_t>;
using atomic_signed_lock_free = /* véase descripción */;
using atomic_unsigned_lock_free = /* véase descripción */;
// tipo bandera y operaciones
struct atomic_flag;
bool atomic_flag_test(const volatile atomic_flag*) noexcept;
bool atomic_flag_test(const atomic_flag*) noexcept;
bool atomic_flag_test_explicit(const volatile atomic_flag*, memory_order) noexcept;
bool atomic_flag_test_explicit(const atomic_flag*, memory_order) noexcept;
bool atomic_flag_test_and_set(volatile atomic_flag*) noexcept;
bool atomic_flag_test_and_set(atomic_flag*) noexcept;
bool atomic_flag_test_and_set_explicit(volatile atomic_flag*, memory_order) noexcept;
bool atomic_flag_test_and_set_explicit(atomic_flag*, memory_order) noexcept;
void atomic_flag_clear(volatile atomic_flag*) noexcept;
void atomic_flag_clear(atomic_flag*) noexcept;
void atomic_flag_clear_explicit(volatile atomic_flag*, memory_order) noexcept;
void atomic_flag_clear_explicit(atomic_flag*, memory_order) noexcept;
void atomic_flag_wait(const volatile atomic_flag*, bool) noexcept;
void atomic_flag_wait(const atomic_flag*, bool) noexcept;
void atomic_flag_wait_explicit(const volatile atomic_flag*,
bool, memory_order) noexcept;
void atomic_flag_wait_explicit(const atomic_flag*,
bool, memory_order) noexcept;
void atomic_flag_notify_one(volatile atomic_flag*) noexcept;
void atomic_flag_notify_one(atomic_flag*) noexcept;
void atomic_flag_notify_all(volatile atomic_flag*) noexcept;
void atomic_flag_notify_all(atomic_flag*) noexcept;
// barreras
extern "C" void atomic_thread_fence(memory_order) noexcept;
extern "C" void atomic_signal_fence(memory_order) noexcept;
}
// en desuso
namespace std {
template<class T>
void atomic_init(volatile atomic<T>*, typename atomic<T>::value_type) noexcept;
template<class T>
void atomic_init(atomic<T>*, typename atomic<T>::value_type) noexcept;
#define ATOMIC_VAR_INIT(value) /* véase descripción */
#define ATOMIC_FLAG_INIT /* véase descripción */
}
Plantilla de clase std::atomic
namespace std {
template<class T> struct atomic {
using value_type = T;
static constexpr bool is_always_lock_free = /* definido por la implementación */;
bool is_lock_free() const volatile noexcept;
bool is_lock_free() const noexcept;
// operaciones en tipos atómicos
constexpr atomic() noexcept(is_nothrow_default_constructible_v<T>);
constexpr atomic(T) noexcept;
atomic(const atomic&) = delete;
atomic& operator=(const atomic&) = delete;
atomic& operator=(const atomic&) volatile = delete;
T load(memory_order = memory_order::seq_cst) const volatile noexcept;
T load(memory_order = memory_order::seq_cst) const noexcept;
operator T() const volatile noexcept;
operator T() const noexcept;
void store(T, memory_order = memory_order::seq_cst) volatile noexcept;
void store(T, memory_order = memory_order::seq_cst) noexcept;
T operator=(T) volatile noexcept;
T operator=(T) noexcept;
T exchange(T, memory_order = memory_order::seq_cst) volatile noexcept;
T exchange(T, memory_order = memory_order::seq_cst) noexcept;
bool compare_exchange_weak(T&, T, memory_order, memory_order) volatile noexcept;
bool compare_exchange_weak(T&, T, memory_order, memory_order) noexcept;
bool compare_exchange_strong(T&, T, memory_order, memory_order) volatile noexcept;
bool compare_exchange_strong(T&, T, memory_order, memory_order) noexcept;
bool compare_exchange_weak(T&, T,
memory_order = memory_order::seq_cst) volatile noexcept;
bool compare_exchange_weak(T&, T, memory_order = memory_order::seq_cst) noexcept;
bool compare_exchange_strong(T&, T,
memory_order = memory_order::seq_cst) volatile noexcept;
bool compare_exchange_strong(T&, T, memory_order = memory_order::seq_cst) noexcept;
void wait(T, memory_order = memory_order::seq_cst) const volatile noexcept;
void wait(T, memory_order = memory_order::seq_cst) const noexcept;
void notify_one() volatile noexcept;
void notify_one() noexcept;
void notify_all() volatile noexcept;
void notify_all() noexcept;
};
}
Especializaciones de std::atomic para tipos enteros
namespace std {
template<> struct atomic</* entero */> {
using value_type = /* entero */;
using difference_type = value_type;
static constexpr bool is_always_lock_free = /* definido por la implementación */;
bool is_lock_free() const volatile noexcept;
bool is_lock_free() const noexcept;
constexpr atomic() noexcept;
constexpr atomic(/* entero */) noexcept;
atomic(const atomic&) = delete;
atomic& operator=(const atomic&) = delete;
atomic& operator=(const atomic&) volatile = delete;
void store(/* entero */, memory_order = memory_order::seq_cst) volatile noexcept;
void store(/* entero */, memory_order = memory_order::seq_cst) noexcept;
/* entero */ operator=(/* entero */) volatile noexcept;
/* entero */ operator=(/* entero */) noexcept;
/* entero */ load(memory_order = memory_order::seq_cst) const volatile noexcept;
/* entero */ load(memory_order = memory_order::seq_cst) const noexcept;
operator /* entero */() const volatile noexcept;
operator /* entero */() const noexcept;
/* entero */ exchange(/* entero */,
memory_order = memory_order::seq_cst) volatile noexcept;
/* entero */ exchange(/* entero */,
memory_order = memory_order::seq_cst) noexcept;
bool compare_exchange_weak(/* entero */&, /* entero */,
memory_order, memory_order) volatile noexcept;
bool compare_exchange_weak(/* entero */&, /* entero */,
memory_order, memory_order) noexcept;
bool compare_exchange_strong(/* entero */&, /* entero */,
memory_order, memory_order) volatile noexcept;
bool compare_exchange_strong(/* entero */&, /* entero */,
memory_order, memory_order) noexcept;
bool compare_exchange_weak(/* entero */&, /* entero */,
memory_order = memory_order::seq_cst) volatile noexcept;
bool compare_exchange_weak(/* entero */&, /* entero */,
memory_order = memory_order::seq_cst) noexcept;
bool compare_exchange_strong(/* entero */&, /* entero */,
memory_order = memory_order::seq_cst) volatile noexcept;
bool compare_exchange_strong(/* entero */&, /* entero */,
memory_order = memory_order::seq_cst) noexcept;
/* entero */ fetch_add(/* entero */,
memory_order = memory_order::seq_cst) volatile noexcept;
/* entero */ fetch_add(/* entero */,
memory_order = memory_order::seq_cst) noexcept;
/* entero */ fetch_sub(/* entero */,
memory_order = memory_order::seq_cst) volatile noexcept;
/* entero */ fetch_sub(/* entero */,
memory_order = memory_order::seq_cst) noexcept;
/* entero */ fetch_and(/* entero */,
memory_order = memory_order::seq_cst) volatile noexcept;
/* entero */ fetch_and(/* entero */,
memory_order = memory_order::seq_cst) noexcept;
/* entero */ fetch_or(/* entero */,
memory_order = memory_order::seq_cst) volatile noexcept;
/* entero */ fetch_or(/* entero */,
memory_order = memory_order::seq_cst) noexcept;
/* entero */ fetch_xor(/* entero */,
memory_order = memory_order::seq_cst) volatile noexcept;
/* entero */ fetch_xor(/* entero */,
memory_order = memory_order::seq_cst) noexcept;
/* entero */ operator++(int) volatile noexcept;
/* entero */ operator++(int) noexcept;
/* entero */ operator--(int) volatile noexcept;
/* entero */ operator--(int) noexcept;
/* entero */ operator++() volatile noexcept;
/* entero */ operator++() noexcept;
/* entero */ operator--() volatile noexcept;
/* entero */ operator--() noexcept;
/* entero */ operator+=(/* entero */) volatile noexcept;
/* entero */ operator+=(/* entero */) noexcept;
/* entero */ operator-=(/* entero */) volatile noexcept;
/* entero */ operator-=(/* entero */) noexcept;
/* entero */ operator&=(/* entero */) volatile noexcept;
/* entero */ operator&=(/* entero */) noexcept;
/* entero */ operator|=(/* entero */) volatile noexcept;
/* entero */ operator|=(/* entero */) noexcept;
/* entero */ operator^=(/* entero */) volatile noexcept;
/* entero */ operator^=(/* entero */) noexcept;
void wait(/* entero */,
memory_order = memory_order::seq_cst) const volatile noexcept;
void wait(/* entero */, memory_order = memory_order::seq_cst) const noexcept;
void notify_one() volatile noexcept;
void notify_one() noexcept;
void notify_all() volatile noexcept;
void notify_all() noexcept;
};
}
Especializaciones de std::atomic para tipos de punto flotante
namespace std {
template<> struct atomic</* punto flotante */> {
using value_type = /* punto flotante */;
using difference_type = value_type;
static constexpr bool is_always_lock_free = /* definido por la implementación */;
bool is_lock_free() const volatile noexcept;
bool is_lock_free() const noexcept;
constexpr atomic() noexcept;
constexpr atomic(/* punto flotante */) noexcept;
atomic(const atomic&) = delete;
atomic& operator=(const atomic&) = delete;
atomic& operator=(const atomic&) volatile = delete;
void store(/* punto flotante */,
memory_order = memory_order_seq_cst) volatile noexcept;
void store(/* punto flotante */,
memory_order = memory_order_seq_cst) noexcept;
/* punto flotante */ operator=(/* punto flotante */) volatile noexcept;
/* punto flotante */ operator=(/* punto flotante */) noexcept;
/* punto flotante */ load(memory_order = memory_order_seq_cst) volatile noexcept;
/* punto flotante */ load(memory_order = memory_order_seq_cst) noexcept;
operator /* punto flotante */() volatile noexcept;
operator /* punto flotante */() noexcept;
/* punto flotante */ exchange(/* punto flotante */,
memory_order = memory_order_seq_cst) volatile noexcept;
/* punto flotante */ exchange(/* punto flotante */,
memory_order = memory_order_seq_cst) noexcept;
bool compare_exchange_weak(/* punto flotante */&, /* punto flotante */,
memory_order, memory_order) volatile noexcept;
bool compare_exchange_weak(/* punto flotante */&, /* punto flotante */,
memory_order, memory_order) noexcept;
bool compare_exchange_strong(/* punto flotante */&, /* punto flotante */,
memory_order, memory_order) volatile noexcept;
bool compare_exchange_strong(/* punto flotante */&, /* punto flotante */,
memory_order, memory_order) noexcept;
bool compare_exchange_weak(/* punto flotante */&, /* punto flotante */,
memory_order = memory_order_seq_cst) volatile noexcept;
bool compare_exchange_weak(/* punto flotante */&, /* punto flotante */,
memory_order = memory_order_seq_cst) noexcept;
bool compare_exchange_strong(/* punto flotante */&, /* punto flotante */,
memory_order = memory_order_seq_cst) volatile noexcept;
bool compare_exchange_strong(/* punto flotante */&, /* punto flotante */,
memory_order = memory_order_seq_cst) noexcept;
/* punto flotante */ fetch_add(/* punto flotante */,
memory_order = memory_order_seq_cst) volatile noexcept;
/* punto flotante */ fetch_add(/* punto flotante */,
memory_order = memory_order_seq_cst) noexcept;
/* punto flotante */ fetch_sub(/* punto flotante */,
memory_order = memory_order_seq_cst) volatile noexcept;
/* punto flotante */ fetch_sub(/* punto flotante */,
memory_order = memory_order_seq_cst) noexcept;
/* punto flotante */ operator+=(/* punto flotante */) volatile noexcept;
/* punto flotante */ operator+=(/* punto flotante */) noexcept;
/* punto flotante */ operator-=(/* punto flotante */) volatile noexcept;
/* punto flotante */ operator-=(/* punto flotante */) noexcept;
void wait(/* punto flotante */,
memory_order = memory_order::seq_cst) const volatile noexcept;
void wait(/* punto flotante */,
memory_order = memory_order::seq_cst) const noexcept;
void notify_one() volatile noexcept;
void notify_one() noexcept;
void notify_all() volatile noexcept;
void notify_all() noexcept;
};
}Especializaciones de std::atomic para tipos puntero
namespace std {
template<class T> struct atomic<T*> {
using value_type = T*;
using difference_type = ptrdiff_t;
static constexpr bool is_always_lock_free = /* definido por la implementación */;
bool is_lock_free() const volatile noexcept;
bool is_lock_free() const noexcept;
constexpr atomic() noexcept;
constexpr atomic(T*) noexcept;
atomic(const atomic&) = delete;
atomic& operator=(const atomic&) = delete;
atomic& operator=(const atomic&) volatile = delete;
void store(T*, memory_order = memory_order::seq_cst) volatile noexcept;
void store(T*, memory_order = memory_order::seq_cst) noexcept;
T* operator=(T*) volatile noexcept;
T* operator=(T*) noexcept;
T* load(memory_order = memory_order::seq_cst) const volatile noexcept;
T* load(memory_order = memory_order::seq_cst) const noexcept;
operator T*() const volatile noexcept;
operator T*() const noexcept;
T* exchange(T*, memory_order = memory_order::seq_cst) volatile noexcept;
T* exchange(T*, memory_order = memory_order::seq_cst) noexcept;
bool compare_exchange_weak(T*&, T*, memory_order, memory_order) volatile noexcept;
bool compare_exchange_weak(T*&, T*, memory_order, memory_order) noexcept;
bool compare_exchange_strong(T*&, T*, memory_order, memory_order) volatile noexcept;
bool compare_exchange_strong(T*&, T*, memory_order, memory_order) noexcept;
bool compare_exchange_weak(T*&, T*,
memory_order = memory_order::seq_cst) volatile noexcept;
bool compare_exchange_weak(T*&, T*,
memory_order = memory_order::seq_cst) noexcept;
bool compare_exchange_strong(T*&, T*,
memory_order = memory_order::seq_cst) volatile noexcept;
bool compare_exchange_strong(T*&, T*,
memory_order = memory_order::seq_cst) noexcept;
T* fetch_add(ptrdiff_t, memory_order = memory_order::seq_cst) volatile noexcept;
T* fetch_add(ptrdiff_t, memory_order = memory_order::seq_cst) noexcept;
T* fetch_sub(ptrdiff_t, memory_order = memory_order::seq_cst) volatile noexcept;
T* fetch_sub(ptrdiff_t, memory_order = memory_order::seq_cst) noexcept;
T* operator++(int) volatile noexcept;
T* operator++(int) noexcept;
T* operator--(int) volatile noexcept;
T* operator--(int) noexcept;
T* operator++() volatile noexcept;
T* operator++() noexcept;
T* operator--() volatile noexcept;
T* operator--() noexcept;
T* operator+=(ptrdiff_t) volatile noexcept;
T* operator+=(ptrdiff_t) noexcept;
T* operator-=(ptrdiff_t) volatile noexcept;
T* operator-=(ptrdiff_t) noexcept;
void wait(T*, memory_order = memory_order::seq_cst) const volatile noexcept;
void wait(T*, memory_order = memory_order::seq_cst) const noexcept;
void notify_one() volatile noexcept;
void notify_one() noexcept;
void notify_all() volatile noexcept;
void notify_all() noexcept;
};
}Plantilla de clase std::atomic_ref
namespace std {
template<class T> struct atomic_ref {
private:
T* ptr; // solo exposición
public:
using value_type = T;
static constexpr size_t required_alignment = /* definido por la implementación */;
static constexpr bool is_always_lock_free = /* definido por la implementación */;
bool is_lock_free() const noexcept;
explicit atomic_ref(T&);
atomic_ref(const atomic_ref&) noexcept;
atomic_ref& operator=(const atomic_ref&) = delete;
void store(T, memory_order = memory_order_seq_cst) const noexcept;
T operator=(T) const noexcept;
T load(memory_order = memory_order_seq_cst) const noexcept;
operator T() const noexcept;
T exchange(T, memory_order = memory_order_seq_cst) const noexcept;
bool compare_exchange_weak(T&, T,
memory_order, memory_order) const noexcept;
bool compare_exchange_strong(T&, T,
memory_order, memory_order) const noexcept;
bool compare_exchange_weak(T&, T,
memory_order = memory_order_seq_cst) const noexcept;
bool compare_exchange_strong(T&, T,
memory_order = memory_order_seq_cst) const noexcept;
void wait(T, memory_order = memory_order::seq_cst) const noexcept;
void notify_one() const noexcept;
void notify_all() const noexcept;
};
}Especializaciones de std::atomic_ref para tipos enteros
namespace std {
template<> struct atomic_ref</* entero */> {
private:
/* entero */* ptr; // solo exposición
public:
using value_type = /* entero */;
using difference_type = value_type;
static constexpr size_t required_alignment = /* definido por la implementación */;
static constexpr bool is_always_lock_free = /* definido por la implementación */;
bool is_lock_free() const noexcept;
explicit atomic_ref(/* entero */&);
atomic_ref(const atomic_ref&) noexcept;
atomic_ref& operator=(const atomic_ref&) = delete;
void store(/* entero */, memory_order = memory_order_seq_cst) const noexcept;
/* entero */ operator=(/* entero */) const noexcept;
/* entero */ load(memory_order = memory_order_seq_cst) const noexcept;
operator /* entero */() const noexcept;
/* entero */ exchange(/* entero */,
memory_order = memory_order_seq_cst) const noexcept;
bool compare_exchange_weak(/* entero */&, /* entero */,
memory_order, memory_order) const noexcept;
bool compare_exchange_strong(/* entero */&, /* entero */,
memory_order, memory_order) const noexcept;
bool compare_exchange_weak(/* entero */&, /* entero */,
memory_order = memory_order_seq_cst) const noexcept;
bool compare_exchange_strong(/* entero */&, /* entero */,
memory_order = memory_order_seq_cst) const noexcept;
/* entero */ fetch_add(/* entero */,
memory_order = memory_order_seq_cst) const noexcept;
/* entero */ fetch_sub(/* entero */,
memory_order = memory_order_seq_cst) const noexcept;
/* entero */ fetch_and(/* entero */,
memory_order = memory_order_seq_cst) const noexcept;
/* entero */ fetch_or(/* entero */,
memory_order = memory_order_seq_cst) const noexcept;
/* entero */ fetch_xor(/* entero */,
memory_order = memory_order_seq_cst) const noexcept;
/* entero */ operator++(int) const noexcept;
/* entero */ operator--(int) const noexcept;
/* entero */ operator++() const noexcept;
/* entero */ operator--() const noexcept;
/* entero */ operator+=(/* entero */) const noexcept;
/* entero */ operator-=(/* entero */) const noexcept;
/* entero */ operator&=(/* entero */) const noexcept;
/* entero */ operatorEspecializaciones de std::atomic_ref para tipos de punto flotante
namespace std {
template<> struct atomic_ref</* punto flotante */> {
private:
/* punto flotante */* ptr; // solo exposición
public:
using value_type = /* punto flotante */;
using difference_type = value_type;
static constexpr size_t required_alignment = /* definido por la implementación */;
static constexpr bool is_always_lock_free = /* definido por la implementación */;
bool is_lock_free() const noexcept;
explicit atomic_ref(/* punto flotante */&);
atomic_ref(const atomic_ref&) noexcept;
atomic_ref& operator=(const atomic_ref&) = delete;
void store(/* punto flotante */, memory_order = memory_order_seq_cst) const noexcept;
/* punto flotante */ operator=(/* punto flotante */) const noexcept;
/* punto flotante */ load(memory_order = memory_order_seq_cst) const noexcept;
operator /* punto flotante */() const noexcept;
/* punto flotante */ exchange(/* punto flotante */,
memory_order = memory_order_seq_cst) const noexcept;
bool compare_exchange_weak(/* punto flotante */&, /* punto flotante */,
memory_order, memory_order) const noexcept;
bool compare_exchange_strong(/* punto flotante */&, /* punto flotante */,
memory_order, memory_order) const noexcept;
bool compare_exchange_weak(/* punto flotante */&, /* punto flotante */,
memory_order = memory_order_seq_cst) const noexcept;
bool compare_exchange_strong(/* punto flotante */&, /* punto flotante */,
memory_order = memory_order_seq_cst) const noexcept;
/* punto flotante */ fetch_add(/* punto flotante */,
memory_order = memory_order_seq_cst) const noexcept;
/* punto flotante */ fetch_sub(/* punto flotante */,
memory_order = memory_order_seq_cst) const noexcept;
/* punto flotante */ operator+=(/* punto flotante */) const noexcept;
/* punto flotante */ operator-=(/* punto flotante */) const noexcept;
void wait(/* punto flotante */, memory_order = memory_order::seq_cst) const noexcept;
void notify_one() const noexcept;
void notify_all() const noexcept;
};
}Especializaciones de std::atomic_ref para tipos puntero
namespace std {
template<class T> struct atomic_ref<T*> {
private:
T** ptr; // solo exposición
public:
using value_type = T*;
using difference_type = ptrdiff_t;
static constexpr size_t required_alignment = /* definido por la implementación */;
static constexpr bool is_always_lock_free = /* definido por la implementación */;
bool is_lock_free() const noexcept;
explicit atomic_ref(T*&);
atomic_ref(const atomic_ref&) noexcept;
atomic_ref& operator=(const atomic_ref&) = delete;
void store(T*, memory_order = memory_order_seq_cst) const noexcept;
T* operator=(T*) const noexcept;
T* load(memory_order = memory_order_seq_cst) const noexcept;
operator T*() const noexcept;
T* exchange(T*, memory_order = memory_order_seq_cst) const noexcept;
bool compare_exchange_weak(T*&, T*,
memory_order, memory_order) const noexcept;
bool compare_exchange_strong(T*&, T*,
memory_order, memory_order) const noexcept;
bool compare_exchange_weak(T*&, T*,
memory_order = memory_order_seq_cst) const noexcept;
bool compare_exchange_strong(T*&, T*,
memory_order = memory_order_seq_cst) const noexcept;
T* fetch_add(difference_type, memory_order = memory_order_seq_cst) const noexcept;
T* fetch_sub(difference_type, memory_order = memory_order_seq_cst) const noexcept;
T* operator++(int) const noexcept;
T* operator--(int) const noexcept;
T* operator++() const noexcept;
T* operator--() const noexcept;
T* operator+=(difference_type) const noexcept;
T* operator-=(difference_type) const noexcept;
void wait(T*, memory_order = memory_order::seq_cst) const noexcept;
void notify_one() const noexcept;
void notify_all() const noexcept;
};
}Clase std::atomic_flag
namespace std {
struct atomic_flag {
constexpr atomic_flag() noexcept;
atomic_flag(const atomic_flag&) = delete;
atomic_flag& operator=(const atomic_flag&) = delete;
atomic_flag& operator=(const atomic_flag&) volatile = delete;
bool test(memory_order = memory_order::seq_cst) const volatile noexcept;
bool test(memory_order = memory_order::seq_cst) const noexcept;
bool test_and_set(memory_order = memory_order::seq_cst) volatile noexcept;
bool test_and_set(memory_order = memory_order::seq_cst) noexcept;
void clear(memory_order = memory_order::seq_cst) volatile noexcept;
void clear(memory_order = memory_order::seq_cst) noexcept;
void wait(bool, memory_order = memory_order::seq_cst) const volatile noexcept;
void wait(bool, memory_order = memory_order::seq_cst) const noexcept;
void notify_one() volatile noexcept;
void notify_one() noexcept;
void notify_all() volatile noexcept;
void notify_all() noexcept;
};
}