Encabezado de la biblioteca estándar <atomic>

 

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

 

Encabezados de la biblioteca estándar

Apoyo del lenguaje <cfloat> <climits> <compare> (C++20) <contracts> (C++26) <coroutine> (C++20) <csetjmp> <csignal> <cstdarg> <cstddef> <cstdint> (C++11) <cstdlib> <exception> <initializer_list> (C++11)   <limits> <new> <source_location> (C++20) <stdfloat> (C++23) <typeinfo> <version> (C++20) Conceptos <concepts> (C++20) Diagnóstico <cassert> <cerrno> <debugging> (C++26) <stacktrace> (C++23) <stdexcept> <system_error> (C++11) Gestión de memoria <memory> <memory_resource> (C++17) <scoped_allocator> (C++11) Metaprogramación <meta> (C++26) <ratio> (C++11) <type_traits> (C++11)

Servicios generales <any> (C++17) <bitset> <bit> (C++20) <charconv> (C++17) <expected> (C++23) <format> (C++20) <functional> <optional> (C++17) <stdbit.h> (C++26) <tuple> (C++11) <typeindex> (C++11) <utility> <variant> (C++17) Contenedores <array> (C++11) <deque> <flat_map> (C++23) <flat_set> (C++23) <forward_list> (C++11) <hive> (C++26) <inplace_vector> (C++26)   <list> <map> <mdspan> (C++23) <queue> <set> <span> (C++20) <stack> <unordered_map> (C++11) <unordered_set> (C++11) <vector> Iteradores <iterator> Rangos <generator> (C++23) <ranges> (C++20)

Algoritmos <algorithm> <numeric> Cadenas <cctype> <cstring> <cuchar> (C++11) <cwchar> <cwctype> <string_view> (C++17) <string> Procesamiento de texto <clocale> <codecvt> (C++11/17/26*) <locale> <regex> (C++11) <text_encoding> (C++26)   Numérica <cfenv> (C++11) <cmath> <complex> <linalg> (C++26) <numbers> (C++20) <random> (C++11) <simd> (C++26) <stdckdint.h> (C++26) <valarray> Tiempo <chrono> (C++11) <ctime> Compatibilidad con C <ccomplex> (C++11/17/20*) <ciso646> (hasta C++20) <cstdalign> (C++11/17/20*) <cstdbool> (C++11/17/20*) <ctgmath> (C++11/17/20*)

Entrada/salida <cinttypes> (C++11) <cstdio> <filesystem> (C++17) <fstream> <iomanip> <iosfwd> <iostream> <ios> <istream> <ostream> <print> (C++23) <spanstream> (C++23) <sstream> <streambuf> <strstream> (C++98/26*) <syncstream> (C++20) Apoyo de concurrencia <atomic> (C++11) <barrier> (C++20) <condition_variable> (C++11) <future> (C++11) <hazard_pointer> (C++26) <latch> (C++20) <mutex> (C++11) <rcu> (C++26) <semaphore> (C++20) <shared_mutex> (C++14) <stdatomic.h> (C++23) <stop_token> (C++20) <thread> (C++11) Apoyo de ejecución <execution> (C++17)

 

Este archivo de encabezado es parte de la biblioteca de operaciones atómicas.

Clases
atomic (C++11)	Plantilla de clase atómica y especializaciones para los tipos bool, enteros y tipos puntero. (plantilla de clase)
atomic_ref (C++20)	Proporciona operaciones atómicas en objetos no atómicos. (plantilla de clase)
atomic_flag (C++11)	El tipo atómico booleano libre de bloqueo. (clase)
memory_order (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
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)
atomic_fetch_addatomic_fetch_add_explicit (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)
atomic_fetch_subatomic_fetch_sub_explicit (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)
atomic_fetch_andatomic_fetch_and_explicit (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)
atomic_fetch_oratomic_fetch_or_explicit (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)
atomic_fetch_xoratomic_fetch_xor_explicit (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)
atomic_waitatomic_wait_explicit (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)
atomic_notify_one (C++20)	Notifica a un hilo bloqueado en atomic_wait. (plantilla de función)
atomic_notify_all (C++20)	Notifica a todos los hilos bloqueados en atomic_wait. (plantilla de función)
atomic_flag_testatomic_flag_test_explicit (C++20)(C++20)	Devuelve atómicamente el valor de la bandera. (función)
atomic_flag_test_and_setatomic_flag_test_and_set_explicit (C++11)(C++11)	Establece atómicamente la bandera a true y devuelve su valor anterior. (función)
atomic_flag_clearatomic_flag_clear_explicit (C++11)(C++11)	Establece atómicamente el valor de la bandera a false. (función)
atomic_flag_waitatomic_flag_wait_explicit (C++20)(C++20)	Bloquea el hilo/subproceso hasta que haya una notificación y la bandera cambie. (función)
atomic_flag_notify_one (C++20)	Notifica a un hilo bloqueado en atomic_flag_wait. (función)
atomic_flag_notify_all (C++20)	Notifica a todos los hilos bloqueados en atomic_flag_wait. (función)
atomic_init (C++11)(en desuso en C++20)	Inicialización no atómica de un objeto atómico construido por defecto. (plantilla de función)
kill_dependency (C++11)	Quita el objeto especificado del árbol de dependencias de std::memory_order_consume. (plantilla de función)
atomic_thread_fence (C++11)	Primitiva de sincronización de barrera genérica de memoria dependiente del orden. (función)
atomic_signal_fence (C++11)	Barrera entre un hilo y un controlador de señales ejecutados en el mismo hilo/subproceso. (función)
Macros de preprocesador
ATOMIC_VAR_INIT (C++11)	Inicialización por constante de una variable atómica de duración de almacenamiento estática. (macro de función)
ATOMIC_FLAG_INIT (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 */ operator

Especializaciones 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;
  };
}