C`atomic_fetch_and(object, operand)` aus `<stdatomic.h>` führt atomar `*object &= operand` auf einem atomaren Ganzzahltyp aus und liefert den Wert vor der Operation. Es ist eine Read-Modify-Write-Operation.
Fortgeschritten · C23C`atomic_fetch_or(object, operand)` aus `<stdatomic.h>` führt atomar `*object |= operand` auf einem atomaren Ganzzahltyp aus und liefert den Wert vor dem Setzen der Bits. Es ist eine Read-Modify-Write-Operation.
Fortgeschritten · C23C`atomic_fetch_sub(object, operand)` aus `<stdatomic.h>` subtrahiert `operand` atomar von einem atomaren Ganzzahl- oder Zeigerobjekt und liefert den Wert vor der Subtraktion. Es ist eine Read-Modify-Write-Operation.
Fortgeschritten · C23C`atomic_fetch_xor(object, operand)` aus `<stdatomic.h>` führt atomar `*object ^= operand` auf einem atomaren Ganzzahltyp aus und liefert den Wert vor dem Umschalten der Bits. Es ist eine Read-Modify-Write-Operation.
Fortgeschritten · C23C`atomic_flag_clear(object)` aus `<stdatomic.h>` versetzt den angegebenen `atomic_flag` atomar in den gelöschten Zustand und liefert keinen Wert. Die Grundform nutzt `memory_order_seq_cst`.
Fortgeschritten · C23C`atomic_flag_test_and_set(object)` aus `<stdatomic.h>` setzt einen `atomic_flag` atomar und liefert seinen vorherigen Zustand: `false` bedeutet Übernahme eines zuvor gelöschten Flags, `true` bedeutet, dass es bereits gesetzt war.
Fortgeschritten · C23C`atomic_init(obj, value)` aus `<stdatomic.h>` initialisiert das angegebene atomare Objekt mit `value`, einschließlich zusätzlichem Implementierungszustand, und liefert keinen Wert. Hat der Speicher keinen deklarierten Typ, erhält er durch den Aufruf den effektiven atomaren Typ `A`.
Fortgeschritten · C23C`atomic_load(object)` liefert atomar den Wert des angegebenen atomaren Objekts. Die Form ohne `_explicit` entspricht `atomic_load_explicit(..., memory_order_seq_cst)`; die `volatile`-Qualifikation des Zeigers bewahrt Geräteregister-Semantik.
Fortgeschritten · C23C`atomic_signal_fence(order)` ordnet nur zwischen Threadcode und einem im selben Thread ausgeführten Signalhandler. Sie besitzt dieselben Ordnungsklassen wie `atomic_thread_fence`, liefert keinen Wert und ist keine generische Funktion.
Fortgeschritten · C23C`atomic_store(object, desired)` ersetzt den Wert des angegebenen atomaren Objekts atomar durch `desired` und liefert nichts. Die Form ohne `_explicit` nutzt `memory_order_seq_cst`; dies ist ein Schreibzugriff, keine Read-Modify-Write-Operation.
Fortgeschritten · C23C`atomic_thread_fence(order)` errichtet eine Speicherbarriere, ohne ein bestimmtes Atom zu lesen oder zu schreiben. Relaxed hat keinen Effekt; consume/acquire ergibt eine Acquire-, release eine Release-, acq_rel beide und seq_cst zusätzlich eine sequentiell konsistente Fence. Sie liefert keinen Wert.
Fortgeschritten · C23Cat_quick_exit aus <stdlib.h> registriert eine Funktion, die von quick_exit aufgerufen wird. Bei Erfolg wird 0 zurückgegeben, bei einem Fehler ein Wert ungleich null.
Mittlere Stufe · C23; repository compiler flag, production runtime not attestedC`bsearch(key, base, nmemb, size, compar)` durchsucht `nmemb` Objekte zu je `size` Byte und liefert einen Zeiger auf ein zum Schlüssel passendes Element oder null. Der Vergleicher erhält zuerst Schlüssel, dann Element und liefert negativ, null oder positiv.
Mittlere Stufe · C23C`c16rtomb(s, c16, ps)` wandelt eine als UTF-16 codierte `char16_t`-Einheit in die Multibyte-Darstellung des aktuellen `LC_CTYPE` um, speichert höchstens `MB_CUR_MAX` Byte und liefert deren Anzahl einschließlich Shiftsequenzen.
Fortgeschritten · C23C`c32rtomb(s, c32, ps)` wandelt eine als UTF-32 codierte `char32_t`-Einheit in die Multibyte-Darstellung des aktuellen `LC_CTYPE` um, speichert höchstens `MB_CUR_MAX` Byte und liefert deren Anzahl einschließlich Shiftsequenzen.
Fortgeschritten · C23C`c8rtomb(s, c8, ps)` wandelt eine als UTF-8 codierte `char8_t`-Einheit in die Multibyte-Darstellung des aktuellen `LC_CTYPE` um, speichert höchstens `MB_CUR_MAX` Byte und liefert deren Anzahl einschließlich Shiftsequenzen.
Fortgeschritten · C23C`calloc(nmemb, size)` aus `<stdlib.h>` reserviert ein Array aus `nmemb` Objekten zu je `size` Byte, setzt jedes Bit des Bereichs auf null und liefert dessen Zeiger oder null. C23 verlangt auch null, wenn `nmemb * size` in `size_t` umlaufen würde.
Mittlere Stufe · C23C`call_once(flag, func)` verwendet ein `once_flag`, um `func` genau einmal beim ersten wirksamen Aufruf mit diesem Flagobjekt aufzurufen, und liefert nichts. Dessen Abschluss synchronisiert mit jedem anderen Aufruf für dasselbe Flag: bereits laufenden, auf `func` wartenden sowie späteren Aufrufen.
Fortgeschritten · C23C`cbrt(x)` aus `<math.h>` nimmt ein `double` und liefert dessen reelle Kubikwurzel; `cbrtf` und `cbrtl` sind die Formen für `float` und `long double`. Ein negatives Argument hat ein negatives reelles Ergebnis.
Grundlagen · C23C`ceil(x)` aus `<math.h>` liefert den kleinsten ganzzahligen Wert, der nicht kleiner als `double x` ist, weiterhin als `double`; `ceilf` und `ceill` bewahren `float` bzw. `long double`. Gerundet wird gegen positive Unendlichkeit.
Grundlagen · C23C`clearerr(stream)` aus `<stdio.h>` löscht sowohl die Dateiende- als auch die Fehleranzeige des angegebenen `FILE`-Streams und liefert keinen Wert. Die Funktion führt keine Ein- oder Ausgabe aus.
Mittlere Stufe · C23C`clock()` aus `<time.h>` liefert die beste verfügbare Näherung der vom Programm aktiv verbrauchten Prozessorzeit seit einer implementationsabhängigen, mit dem Aufruf verbundenen Epoche. Das Ergebnis ist `clock_t`; Division durch `CLOCKS_PER_SEC` ergibt Sekunden.
Mittlere Stufe · C23C`cnd_broadcast(cond)` aus `<threads.h>` entsperrt alle Threads, die zum Aufrufzeitpunkt auf dieser Condition Variable blockiert sind. Ohne Wartende geschieht nichts; Rückgabe ist `thrd_success` oder `thrd_error`, wenn die Anforderung nicht erfüllt werden kann.
Fortgeschritten · C23C`cnd_destroy(cond)` gibt alle Ressourcen einer zuvor initialisierten Condition Variable frei und liefert keinen Wert. C23 verlangt, dass zum Aufrufzeitpunkt kein Thread darauf blockiert ist.
Mittlere Stufe · C23