Espacios de nombres
Variantes

    std::atomic

    De cppreference.com
     
    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
    (C++11)
    (C++20)
    Funciones
    (C++11)(C++11)
    (C++11)(C++11)
    (C++11)(C++11)
    (C++11)(C++11)(C++11)(C++11)
    (C++11)(C++11)
    (C++11)(C++11)
    (C++11)(C++11)
    (C++11)(C++11)
    (C++11)(C++11)
    (C++11)
    (C++20)(C++20)
    (C++20)
    (C++20)
    Banderas atómicas
    (C++11)
    (C++11)(C++11)
    (C++11)(C++11)
    (C++20)(C++20)
    (C++20)(C++20)
    (C++20)
    (C++20)
    Inicialización
    (C++11)(en desuso en C++20)
    (C++11)(en desuso en C++20)
    (C++11)(en desuso en C++20)
    Ordenamiento de memoria
    (C++11)
    (C++11)
    (C++11)
    (C++11)
     
    std::atomic
    Las funciones miembro
    Original:
    Member functions
    The text has been machine-translated via Google Translate.
    You can help to correct and verify the translation. Click here for instructions.
    Funciones especializadas miembros
    Original:
    Specialized member functions
    The text has been machine-translated via Google Translate.
    You can help to correct and verify the translation. Click here for instructions.
     
    <tbody> </tbody>
    Definido en el archivo de encabezado <atomic>
    template< class T > struct atomic;
    		 (1) (desde C++11)
    template< class U > struct atomic<U*>;
    		 (2) (desde C++11)
    Definido en el archivo de encabezado <memory>
    template< class U > struct atomic<std::shared_ptr<U>>;
    		 (3) (desde C++20)
    template< class U > struct atomic<std::weak_ptr<U>>;
    		 (4) (desde C++20)
    Definido en el archivo de encabezado <stdatomic.h>
    #define _Atomic(T) /* véase más abajo */
    		 (5) (desde C++23)
    See More

    Cada instanciación y especialización completa de la plantilla std::atomic define un tipo atómico. Si un hilo escribe en un objeto atómico mientras otro hilo lee de él, el comportamiento está bien definido (véase modelo de memoria para obtener detalles sobre las carreras de datos).

    Además, los accesos a los objetos atómicos pueden establecer una sincronización entre hilos y ordenar los accesos a la memoria no atómica como se especifica en std::memory_order.

    std::atomic no se puede copiar ni mover.

    La macro de compatibilidad _Atomic se proporciona en <stdatomic.h> tal que _Atomic(T) es idéntico a std::atomic<T> mientras que ambos están bien formados.

    No se especifica si alguna declaración en el espacio de nombres std está disponible cuando se incluye <stdatomic.h>.

    Especializaciones

    Plantilla primaria

    La plantilla primaria std::atomic puede instanciarse con cualquier tipo T TriviallyCopyable que satisfaga tanto a CopyConstructible como CopyAssignable. El programa está mal formado si alguno de los siguientes valores es false:

    • std::is_trivially_copyable<T>::value
    • std::is_copy_constructible<T>::value
    • std::is_move_constructible<T>::value
    • std::is_copy_assignable<T>::value
    • std::is_move_assignable<T>::value
    struct Counters { int a; int b; }; // tipo trivialmente copiable definido por el usuario
std::atomic<Counters> cnt;         // especialización para el tipo definido por el usuario

    std::atomic<bool> usa la plantilla primaria. Se garantiza que sea una estructura (struct) con diseño/distribución estándar.

    Especializaciones parciales

    La biblioteca estándar proporciona especializaciones parciales de la plantilla std::atomic para los siguientes tipos con propiedades adicionales que la plantilla primaria no tiene:

    2) Especializaciones parciales std::atomic<U*> para todos los tipos puntero. Estas especializaciones tienen diseño/distribución estándar, constructores por defecto triviales, (hasta C++20) y destructores triviales. Además de las operaciones proporcionadas para todos los tipos atómicos, estas especializaciones también admiten operaciones aritméticas atómicas apropiadas para los tipos puntero, como fetch_add, fetch_sub.

    3-4) Especializaciones parciales std::atomic<std::shared_ptr<U>> y std::atomic<std::weak_ptr<U>> se proporcionan para std::shared_ptr y std::weak_ptr.

    Véase std::atomic<std::shared_ptr> y std::atomic<std::weak_ptr> para más detalles.

    		(desde C++20)

    Especializaciones para tipos enteros

    Cuando se crea una instancia con uno de los tipos enteros, std::atomic proporciona operaciones atómicas adicionales apropiadas para tipos enteros, tales como fetch_add, fetch_sub, fetch_and, fetch_or, fetch_xor:

    • Los tipos carácter char, char8_t (desde C++20), char16_t, char32_t, y wchar_t;
    • Los tipos enteros con signo estándar: signed char, short, int, long, y long long;
    • Los tipos enteros sin signo estándar: unsigned char, unsigned short, unsigned int, unsigned long, y unsigned long long;
    • Cualquier tipo entero adicional necesitado por las definiciones de tipo en el archivo de encabezado <cstdint>.

    Adicionalmente, la especialización std::atomic<Integral> resultante tiene un diseño/distribución estándar, un constructor trivial por defecto, (hasta C++20) y un destructor trivial. La aritmética de enteros con signo se define para utilizar el complemento a dos; no hay resultados indefinidos.

    Especializaciones para tipos de punto flotante

    Cuando se crea una instancia con uno de los tipos de punto flotante float, double, y long double, std::atomic proporciona operaciones atómicas adicionales apropiadas para tipos de punto flotante, tales como fetch_add y fetch_sub.

    Adicionalmente, la especialización std::atomic<Floating> resultante tiene un diseño/distribución estándar y un destructor trivial.

    Ninguna operación da como resultado un 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 llamante.

    		(desde C++20)

    Alias de tipos

    Los alias de tipos se proporcionan para bool y todos los tipos enteros listados anteriormente, de la siguiente manera:

    Plantilla:cpp/atomic/atomic/dsc atomic lock free aliases
    Alias para todos los std::atomic<Integral>
    (C++11)
    		 std::atomic<bool>
    (typedef) [editar]
    (C++11)
    		 std::atomic<char>
    (typedef) [editar]
    (C++11)
    		 std::atomic<signed char>
    (typedef) [editar]
    (C++11)
    		 std::atomic<unsigned char>
    (typedef) [editar]
    (C++11)
    		 std::atomic<short>
    (typedef) [editar]
    (C++11)
    		 std::atomic<unsigned short>
    (typedef) [editar]
    (C++11)
    		 std::atomic<int>
    (typedef) [editar]
    (C++11)
    		 std::atomic<unsigned int>
    (typedef) [editar]
    (C++11)
    		 std::atomic<long>
    (typedef) [editar]
    (C++11)
    		 std::atomic<unsigned long>
    (typedef) [editar]
    (C++11)
    		 std::atomic<long long>
    (typedef) [editar]
    (C++11)
    		 std::atomic<unsigned long long>
    (typedef) [editar]
    (C++20)
    		 std::atomic<char8_t>
    (typedef) [editar]
    (C++11)
    		 std::atomic<char16_t>
    (typedef) [editar]
    (C++11)
    		 std::atomic<char32_t>
    (typedef) [editar]
    (C++11)
    		 std::atomic<wchar_t>
    (typedef) [editar]
    (C++11)(opcional)
    		 std::atomic<std::int8_t>
    (typedef) [editar]
    (C++11)(opcional)
    		 std::atomic<std::uint8_t>
    (typedef) [editar]
    (C++11)(opcional)
    		 std::atomic<std::int16_t>
    (typedef) [editar]
    (C++11)(opcional)
    		 std::atomic<std::uint16_t>
    (typedef) [editar]
    (C++11)(opcional)
    		 std::atomic<std::int32_t>
    (typedef) [editar]
    (C++11)(opcional)
    		 std::atomic<std::uint32_t>
    (typedef) [editar]
    (C++11)(opcional)
    		 std::atomic<std::int64_t>
    (typedef) [editar]
    (C++11)(opcional)
    		 std::atomic<std::uint64_t>
    (typedef) [editar]
    (C++11)
    		 std::atomic<std::int_least8_t>
    (typedef) [editar]
    (C++11)
    		 std::atomic<std::uint_least8_t>
    (typedef) [editar]
    (C++11)
    		 std::atomic<std::int_least16_t>
    (typedef) [editar]
    (C++11)
    		 std::atomic<std::uint_least16_t>
    (typedef) [editar]
    (C++11)
    		 std::atomic<std::int_least32_t>
    (typedef) [editar]
    (C++11)
    		 std::atomic<std::uint_least32_t>
    (typedef) [editar]
    (C++11)
    		 std::atomic<std::int_least64_t>
    (typedef) [editar]
    (C++11)
    		 std::atomic<std::uint_least64_t>
    (typedef) [editar]
    (C++11)
    		 std::atomic<std::int_fast8_t>
    (typedef) [editar]
    (C++11)
    		 std::atomic<std::uint_fast8_t>
    (typedef) [editar]
    (C++11)
    		 std::atomic<std::int_fast16_t>
    (typedef) [editar]
    (C++11)
    		 std::atomic<std::uint_fast16_t>
    (typedef) [editar]
    (C++11)
    		 std::atomic<std::int_fast32_t>
    (typedef) [editar]
    (C++11)
    		 std::atomic<std::uint_fast32_t>
    (typedef) [editar]
    (C++11)
    		 std::atomic<std::int_fast64_t>
    (typedef) [editar]
    (C++11)
    		 std::atomic<std::uint_fast64_t>
    (typedef) [editar]
    (C++11)(opcional)
    		 std::atomic<std::intptr_t>
    (typedef) [editar]
    (C++11)(opcional)
    		 std::atomic<std::uintptr_t>
    (typedef) [editar]
    (C++11)
    		 std::atomic<std::size_t>
    (typedef) [editar]
    (C++11)
    		 std::atomic<std::ptrdiff_t>
    (typedef) [editar]
    (C++11)
    		 std::atomic<std::intmax_t>
    (typedef) [editar]
    (C++11)
    		 std::atomic<std::uintmax_t>
    (typedef) [editar]
    Alias para tipos de propósito especial

    Nota: std::atomic_intN_t, std::atomic_uintN_t, std::atomic_intptr_t, y atomic_uintptr_t están definidos si y solo si std::intN_t, std::uintN_t, std::intptr_t, y std::uintptr_t están definidos, respectivamente.

    std::atomic_signed_lock_free y std::atomic_unsigned_lock_free son opcionales en implementaciones libres.

    		(desde C++20)

    Tipos miembro

    Tipo miembro Definición
    value_type T (Independientemente de si está especializado o no.)
    difference_type value_type (Solo para atomic<Integral> y las especializaciones de atomic<Floating> (desde C++20))
    std::ptrdiff_t (solo para las especializadones de atomic<U*>)

    difference_type no se define en la plantilla primaria de atomic o en las especializaciones parciales de std::shared_ptr y std::weak_ptr.

    Funciones miembro

    		 Construye un objeto atómico.
    (función miembro pública) [editar]
    almacena un valor en un objeto atómico
    Original:
    stores a value into an atomic object
    The text has been machine-translated via Google Translate.
    You can help to correct and verify the translation. Click here for instructions.

    (función miembro pública) [editar]
    		Comprueba si el objeto atómico es sin bloqueo.
    (función miembro pública) [editar]
    (C++11)
    atómicamente sustituye el valor del objeto atómico con un argumento no atómica
    Original:
    atomically replaces the value of the atomic object with a non-atomic argument
    The text has been machine-translated via Google Translate.
    You can help to correct and verify the translation. Click here for instructions.

    (función miembro pública) [editar]
    (C++11)
    atómicamente obtiene el valor del objeto atómica
    Original:
    atomically obtains the value of the atomic object
    The text has been machine-translated via Google Translate.
    You can help to correct and verify the translation. Click here for instructions.

    (función miembro pública) [editar]
    carga un valor de un objeto atómico
    Original:
    loads a value from an atomic object
    The text has been machine-translated via Google Translate.
    You can help to correct and verify the translation. Click here for instructions.

    (función miembro pública) [editar]
    (C++11)
    automáticamente reemplazado el valor del objeto atómico y obtiene el valor que tenía antes
    Original:
    atomically replaced the value of the atomic object and obtains the value held previously
    The text has been machine-translated via Google Translate.
    You can help to correct and verify the translation. Click here for instructions.

    (función miembro pública) [editar]
    atómicamente compara el valor del objeto atómica con no atómica argumento y realiza intercambio atómico si carga igual o atómica si no
    Original:
    atomically compares the value of the atomic object with non-atomic argument and performs atomic exchange if equal or atomic load if not
    The text has been machine-translated via Google Translate.
    You can help to correct and verify the translation. Click here for instructions.

    (función miembro pública) [editar]
    (C++20)
    		 Bloquea el hilo hasta que se notifique y el valor atómico cambie.
    (función miembro pública) [editar]
    (C++20)
    		 Notifica al menos a un hilo/subproceso esperando al objeto atómico.
    (función miembro pública) [editar]
    (C++20)
    		 Notifica a todos los hilos/subprocesos bloqueados esperando al objeto atómico.
    (función miembro pública) [editar]

    Constants

    [estático] (C++17)
    		 Indica que el tipo es siempre libre de bloqueo.
    (constante miembro pública estática) [editar]

    Funciones miembro especializadas

    (C++11)
    atómicamente agrega el argumento con el valor almacenado en el objeto atómico y obtiene el valor que tenía antes
    Original:
    atomically adds the argument to the value stored in the atomic object and obtains the value held previously
    The text has been machine-translated via Google Translate.
    You can help to correct and verify the translation. Click here for instructions.

    (función miembro pública) [editar]
    (C++11)
    atómicamente resta el argumento de que el valor almacenado en el objeto atómico y obtiene el valor que tenía antes
    Original:
    atomically subtracts the argument from the value stored in the atomic object and obtains the value held previously
    The text has been machine-translated via Google Translate.
    You can help to correct and verify the translation. Click here for instructions.

    (función miembro pública) [editar]
    (C++11)
    realiza atómicamente AND bit a bit entre el argumento y el valor del objeto atómico y obtiene el valor que tenía antes
    Original:
    atomically performs bitwise AND between the argument and the value of the atomic object and obtains the value held previously
    The text has been machine-translated via Google Translate.
    You can help to correct and verify the translation. Click here for instructions.

    (función miembro pública) [editar]
    (C++11)
    		 atomically performs bitwise OR between the argument and the value of the atomic object and obtains the value held previously
    (función miembro pública) [editar]
    (C++11)
    atómicamente realiza bit a bit XOR entre el argumento y el valor del objeto atómico y obtiene el valor que tenía antes
    Original:
    atomically performs bitwise XOR between the argument and the value of the atomic object and obtains the value held previously
    The text has been machine-translated via Google Translate.
    You can help to correct and verify the translation. Click here for instructions.

    (función miembro pública) [editar]
    		aumenta o disminuye el valor atómico en uno
    (función miembro pública) [editar]
    suma, resta, o presta XOR bit a bit AND, OR, con el valor atómico
    Original:
    adds, subtracts, or performs bitwise AND, OR, XOR with the atomic value
    The text has been machine-translated via Google Translate.
    You can help to correct and verify the translation. Click here for instructions.

    (función miembro pública) [editar]

    Notas

    Hay equivalentes de plantilla de función no miembro para todas las funciones miembro de std::atomic. Esas funciones que no son miembros pueden sobrecargarse adicionalmente para tipos que no son especializaciones de std::atomic, pero que pueden garantizar la atomicidad. El único tipo de este tipo en la biblioteca estándar es std::shared_ptr<U>.

    _Atomic es una palabra clave y se usa para proporcionar tipos atómicos en C.

    Se recomienda que las implementaciones aseguren que la representación de _Atomic(T) en C sea la misma que la de std::atomic<T> en C++ para cada tipo posible T. Los mecanismos utilizados para garantizar la atomicidad y el orden de la memoria deben ser compatibles.

    En gcc y clang, algunas de las funciones descritas aquí requieren vinculación contra -latomic.

    Informes de defectos

    Los siguientes informes de defectos de cambio de comportamiento se aplicaron de manera retroactiva a los estándares de C++ publicados anteriormente.

    ID Aplicado a Comportamiento según lo publicado Comportamiento correcto
    LWG 2441 C++11 Faltaban typedefs para las versiones atómicas de
    tipos enteros de anchura fija opcionales.     		Se añadieron.
    P0558R1 C++11 La deducción de argumentos de plantilla para algunas funciones
    de tipos atómicos podría fallar accidentalemente;
    se proporcionaban operaciones de puntero inválidas.     		La especificación se reescribió sustancialmente:
    Se añadieron typedefs miembro value_type y difference_type.
    LWG 3012 C++11 Se permitía std::atomic<T> para
    cualquier T que fuera trivialmente copiable pero no copiable.     		Tales especializaciones se prohíben.

    Véase también

    (C++11)
    		 El tipo atómico booleano libre de bloqueo.
    (clase) [editar]
    (C++20)
    		 Puntero compartido atómico.
    (especialización de plantilla de clase) [editar]
    (C++20)
    		 Puntero débil atómico.
    (especialización de plantilla de clase) [editar]
    Documentación de C para Tipos atómicos