Standardbibliothek-Header <stdatomic.h> (C11)

 

C

Compiler-Unterstützung

Sprache

Header

Typunterstützung

Programm-Dienstprogramme

Unterstützung für variable Funktionsargumente

Fehlerbehandlung

Dynamische Speicherverwaltung

Bibliothek für Zeichenketten

Algorithmen

Numerik

Datums- und Zeitdienstprogramme

Ein-/Ausgabeunterstützung

Lokalisierungsunterstützung

Unterstützung für Nebenläufigkeit (C11)

Technische Spezifikationen

Symbolindex

 

Standard Library-Header

<assert.h> <complex.h> (C99) <ctype.h> <errno.h> <fenv.h> (C99) <float.h> <inttypes.h> (C99)     <iso646.h> (C95) <limits.h> <locale.h> <math.h>

<setjmp.h> <signal.h> <stdalign.h> (C11*) <stdarg.h> <stdatomic.h> (C11)     <stdbit.h> (C23) <stdbool.h> (C99*) <stdckdint.h> (C23) <stddef.h> <stdint.h> (C99) <stdio.h>

<stdlib.h> <stdmchar.h> (C29) <stdnoreturn.h> (C11*) <string.h> <tgmath.h> (C99) <threads.h> (C11) <time.h> <uchar.h> (C11) <wchar.h> (C95) <wctype.h> (C95)

 

Dieser Header bietet atomare Operationen, insbesondere ist er Teil der Nebenläufigkeitsunterstützungsbibliothek.

Atomare Operationen

Operationen auf atomaren Typen
ATOMIC_BOOL_LOCK_FREEATOMIC_CHAR_LOCK_FREEATOMIC_CHAR16_T_LOCK_FREEATOMIC_CHAR32_T_LOCK_FREEATOMIC_WCHAR_T_LOCK_FREEATOMIC_SHORT_LOCK_FREEATOMIC_INT_LOCK_FREEATOMIC_LONG_LOCK_FREEATOMIC_LLONG_LOCK_FREEATOMIC_POINTER_LOCK_FREE (C11)	zeigt an, dass der gegebene atomare Typ sperrfrei ist (Makro-Konstante)
atomic_is_lock_free (C11)	zeigt an, ob das atomare Objekt sperrfrei ist (Funktion)
atomic_storeatomic_store_explicit (C11)	speichert einen Wert in einem atomaren Objekt (Funktion)
atomic_loadatomic_load_explicit (C11)	liest einen Wert aus einem atomaren Objekt (Funktion)
atomic_exchangeatomic_exchange_explicit (C11)	tauscht einen Wert mit dem Wert eines atomaren Objekts aus (Funktion)
atomic_compare_exchange_strongatomic_compare_exchange_strong_explicitatomic_compare_exchange_weakatomic_compare_exchange_weak_explicit (C11)	tauscht einen Wert mit einem atomaren Objekt aus, wenn der alte Wert der erwartete ist, andernfalls liest er den alten Wert (Funktion)
atomic_fetch_addatomic_fetch_add_explicit (C11)	atomare Addition (Funktion)
atomic_fetch_subatomic_fetch_sub_explicit (C11)	atomare Subtraktion (Funktion)
atomic_fetch_oratomic_fetch_or_explicit (C11)	atomares bitweises ODER (Funktion)
atomic_fetch_xoratomic_fetch_xor_explicit (C11)	atomares bitweises exklusives ODER (Funktion)
atomic_fetch_andatomic_fetch_and_explicit (C11)	atomares bitweises UND (Funktion)
Flag-Typ und Operationen
atomic_flag (C11)	sperrfreies atomares boolesches Flag (Struktur)
atomic_flag_test_and_setatomic_flag_test_and_set_explicit (C11)	setzt ein atomic_flag auf true und gibt den alten Wert zurück (Funktion)
atomic_flag_clearatomic_flag_clear_explicit (C11)	setzt ein atomic_flag auf false (Funktion)
Initialisierung
atomic_init (C11)	initialisiert ein vorhandenes atomares Objekt (Funktion)
ATOMIC_VAR_INIT (C11)(veraltet in C17)(entfernt in C23)	initialisiert ein neues atomares Objekt (Makro-Funktion)
ATOMIC_FLAG_INIT (C11)	initialisiert ein neues atomic_flag (Makro-Konstante)
Speichersynchronisationsordnung
memory_order (C11)	definiert Speicherreihenfolgebeschränkungen (Enum)
kill_dependency (C11)	bricht eine Abhängigkeitskette für memory_order_consume (Makro-Funktion)
atomic_thread_fence (C11)	allgemeines speicherordnungsabhängiges Fence-Synchronisationsprimitiv (Funktion)
atomic_signal_fence (C11)	Fence zwischen einem Thread und einem Signal-Handler, der im selben Thread ausgeführt wird (Funktion)

Bequeme Typ-Aliase
Typedef-Name	Vollständiger Typ-Name
atomic_bool (C11)	_Atomic _Bool
atomic_char (C11)	_Atomic char
atomic_schar (C11)	_Atomic signed char
atomic_uchar (C11)	_Atomic unsigned char
atomic_short (C11)	_Atomic short
atomic_ushort (C11)	_Atomic unsigned short
atomic_int (C11)	_Atomic int
atomic_uint (C11)	_Atomic unsigned int
atomic_long (C11)	_Atomic long
atomic_ulong (C11)	_Atomic unsigned long
atomic_llong (C11)	_Atomic long long
atomic_ullong (C11)	_Atomic unsigned long long
atomic_char8_t (C23)	_Atomic char8_t
atomic_char16_t (C11)	_Atomic char16_t
atomic_char32_t (C11)	_Atomic char32_t
atomic_wchar_t (C11)	_Atomic wchar_t
atomic_int_least8_t (C11)	_Atomic int_least8_t
atomic_uint_least8_t (C11)	_Atomic uint_least8_t
atomic_int_least16_t (C11)	_Atomic int_least16_t
atomic_uint_least16_t (C11)	_Atomic uint_least16_t
atomic_int_least32_t (C11)	_Atomic int_least32_t
atomic_uint_least32_t (C11)	_Atomic uint_least32_t
atomic_int_least64_t (C11)	_Atomic int_least64_t
atomic_uint_least64_t (C11)	_Atomic uint_least64_t
atomic_int_fast8_t (C11)	_Atomic int_fast8_t
atomic_uint_fast8_t (C11)	_Atomic uint_fast8_t
atomic_int_fast16_t (C11)	_Atomic int_fast16_t
atomic_uint_fast16_t (C11)	_Atomic uint_fast16_t
atomic_int_fast32_t (C11)	_Atomic int_fast32_t
atomic_uint_fast32_t (C11)	_Atomic uint_fast32_t
atomic_int_fast64_t (C11)	_Atomic int_fast64_t
atomic_uint_fast64_t (C11)	_Atomic uint_fast64_t
atomic_intptr_t (C11)	_Atomic intptr_t
atomic_uintptr_t (C11)	_Atomic uintptr_t
atomic_size_t (C11)	_Atomic size_t
atomic_ptrdiff_t (C11)	_Atomic ptrdiff_t
atomic_intmax_t (C11)	_Atomic intmax_t
atomic_uintmax_t (C11)	_Atomic uintmax_t

Synopsis

#define __STDC_VERSION_STDATOMIC_H__ 202311L
 
void atomic_init(volatile A* obj, /*C*/ value);
/*type*/ kill_dependency(/*type*/ y);
void atomic_thread_fence(memory_order order);
void atomic_signal_fence(memory_order order);
bool atomic_is_lock_free(const volatile A* obj);
void atomic_store(volatile A* object, /*C*/ desired);
void atomic_store_explicit(volatile A* object, /*C*/ desired, memory_order order);
/*C*/ atomic_load(const volatile A* object);
/*C*/ atomic_load_explicit(const volatile A* object, memory_order order);
/*C*/ atomic_exchange(volatile A* object, /*C*/ desired);
/*C*/ atomic_exchange_explicit(volatile A* object, /*C*/ desired, memory_order order);
bool atomic_compare_exchange_strong(volatile A* object, /*C*/* expected, /*C*/ desired);
bool atomic_compare_exchange_strong_explicit(volatile A* object, /*C*/* expected,
/*C*/ desired, memory_order success, memory_order failure);
bool atomic_compare_exchange_weak(volatile A* object, /*C*/* expected, /*C*/ desired);
bool atomic_compare_exchange_weak_explicit(volatile A* object, /*C*/* expected,
/*C*/ desired, memory_order success, memory_order failure);
/*C*/ /*atomic_fetch_key*/(volatile A* object, M operand);
/*C*/ /*atomic_fetch_key_explicit*/(volatile A* object, M operand, memory_order order);
bool atomic_flag_test_and_set(volatile atomic_flag* object);
bool atomic_flag_test_and_set_explicit(volatile atomic_flag* object,
memory_order order);
void atomic_flag_clear(volatile atomic_flag* object);
void atomic_flag_clear_explicit(volatile atomic_flag* object,
                                memory_order order);