C`cnd_init(cond)` erzeugt eine neue Condition Variable und speichert bei Erfolg in `*cond` einen sie eindeutig identifizierenden Wert. Rückgabe ist `thrd_success`, bei Speichermangel `thrd_nomem` oder `thrd_error`, wenn die Anforderung nicht erfüllbar ist.
Mittlere Stufe · C23C`cnd_signal(cond)` entsperrt einen der zum Aufrufzeitpunkt auf `cond` blockierten Threads. Ohne Wartenden geschieht nichts und `thrd_success` wird geliefert; sonst lautet das Ergebnis `thrd_success` oder `thrd_error`.
Fortgeschritten · C23C`cnd_timedwait(cond, mtx, ts)` entsperrt den gehaltenen `mtx` atomar und wartet auf Signal/Broadcast, die absolute `TIME_UTC`-Kalenderzeit in `*ts` oder Entsperren aus unbestimmtem Grund. Vor normaler Rückkehr sperrt es den Mutex erneut.
Fortgeschritten · C23C`cnd_wait(cond, mtx)` aus `<threads.h>` entsperrt den gehaltenen `mtx` atomar und blockiert bis zu Signal, Broadcast oder Entsperren aus unbestimmtem Grund. Vor der Rückkehr sperrt es `mtx` erneut; Ergebnis ist `thrd_success` oder `thrd_error`.
Fortgeschritten · C23C`copysign(x, y)` aus `<math.h>` liefert den Betrag von `x` mit dem Vorzeichen von `y`; bei NaN als `x` entsteht NaN mit dem Vorzeichen von `y`. Ist einer der Werte vorzeichenlos, ist laut C23 das etwaige Ergebnisvorzeichen implementationsdefiniert.
Mittlere Stufe · C23C`cos(x)` aus `<math.h>` berechnet den Kosinus des in Radiant gemessenen `x` und liefert `double`; `cosf` und `cosl` bedienen `float` und `long double`. Für endliche Argumente nennt Basis-C23 keinen Definitionsbereichsfehler.
Grundlagen · C23C`cosh(x)` aus `<math.h>` liefert den Hyperbelkosinus von `x`, mathematisch `(e^x + e^-x) / 2`. Die Funktion ist gerade; C23 verlangt einen Bereichsfehler, wenn der Betrag des endlichen `x` zu groß ist.
Mittlere Stufe · C23C`ctime(timer)` aus `<time.h>` wandelt die bezeichnete `time_t`-Kalenderzeit in eine lokale Zeitzeichenfolge um und liefert den Zeiger des Äquivalents `asctime(localtime(timer))`. In C23 trägt die Deklaration `[[deprecated]]`; die obsoleszente Funktion ist in neuem Code zu vermeiden.
Mittlere Stufe · C23C`difftime(time1, time0)` aus `<time.h>` berechnet `time1 - time0` für zwei `time_t`-Kalenderzeiten und liefert die Differenz in Sekunden als `double`. Das ist portabel, weil die Codierung von `time_t` nicht festgelegt ist.
Mittlere Stufe · C23C`div(numer, denom)` aus `<stdlib.h>` berechnet Ganzzahlquotient und Rest gemeinsam und liefert `div_t` mit `quot` und `rem`. Ganzzahldivision schneidet gegen null ab, und `numer == quot * denom + rem`.
Grundlagen · C23C`errno` aus `<errno.h>` ist ein Makro, das zu einem änderbaren Lvalue vom Typ `int` mit Thread-Speicherdauer expandiert. Es ist weder Funktion noch Konstante: `errno`, niemals `errno()`, und jeder Thread hat sein eigenes Objekt.
Mittlere Stufe · C23C`exit(status)` aus `<stdlib.h>` bewirkt normale Programmbeendigung und kehrt nicht zurück. Zuerst werden `atexit`-Funktionen in umgekehrter Registrierungsfolge aufgerufen, dann Streams geleert und geschlossen, `tmpfile`-Dateien entfernt und schließlich der Status an die Hostumgebung gegeben.
Fortgeschritten · C23C`exp(x)` aus `<math.h>` berechnet die Exponentialfunktion zur Basis e und liefert `e^x` als `double`; `expf` und `expl` bedienen `float` und `long double`. C23 verlangt einen Bereichsfehler, wenn der Betrag des endlichen `x` zu groß ist.
Mittlere Stufe · C23C`exp2(x)` aus `<math.h>` berechnet `2^x` und liefert das Ergebnis als `double`; `exp2f` und `exp2l` nehmen entsprechend `float` und `long double`. C23 meldet einen Bereichsfehler, wenn der Betrag des endlichen `x` zu groß ist.
Mittlere Stufe · C23C`expm1(x)` aus `<math.h>` berechnet `e^x - 1` als `double`; `expm1f` und `expm1l` bedienen `float` und `long double`. Für winziges `x` bewahrt die Funktion Genauigkeit, während getrenntes `exp(x) - 1` durch Subtraktion naher Werte Ziffern verliert.
Mittlere Stufe · C23C`fabs(x)` aus `<math.h>` liefert den Absolutbetrag eines `double`; `fabsf` und `fabsl` bedienen `float` und `long double`. Anders als ganzzahliges `abs` hat die Funktion kein Problem mit einem nicht darstellbaren positiven Gegenstück der kleinsten Ganzzahl.
Grundlagen · C23C`fclose(stream)` aus `<stdio.h>` leert den angegebenen Datenstrom, liefert ungeschriebene Daten an die Hostumgebung, verwirft ungelesene Eingabe, schließt die zugehörige Datei und trennt das `FILE`-Objekt. Bei Erfolg wird null, bei Fehler `EOF` geliefert.
Mittlere Stufe · C23C`feof(stream)` aus `<stdio.h>` prüft die Dateiendeanzeige eines offenen `FILE`-Datenstroms. Es liefert genau dann einen Wert ungleich null, wenn die Anzeige gesetzt ist; es liest nichts und liefert nicht selbst die Konstante `EOF`.
Grundlagen · C23C`ferror(stream)` aus `<stdio.h>` prüft die Fehleranzeige eines offenen `FILE`-Datenstroms. Es liefert genau dann einen Wert ungleich null, wenn die Anzeige gesetzt ist; es führt kein I/O aus, liefert keinen konkreten Fehlercode und ändert den Datenstromzustand nicht.
Grundlagen · C23C`fflush(stream)` aus `<stdio.h>` übergibt bei einem Ausgabe- oder geeigneten Aktualisierungsstrom ungeschriebene gepufferte Daten an die Hostumgebung. `fflush(NULL)` versucht dies für alle solchen offenen Ströme; Ergebnis ist null bei Erfolg oder `EOF` mit gesetzter Fehleranzeige bei Fehlschlag.
Mittlere Stufe · C23C`fgetc(stream)` aus `<stdio.h>` liest das nächste Zeichen eines Eingabestroms, verschiebt die Position und liefert das als `unsigned char` interpretierte und dann zu `int` konvertierte Byte. Bei Dateiende oder Fehler wird `EOF` geliefert und die entsprechende Anzeige gesetzt.
Grundlagen · C23C`fgetpos(stream, pos)` aus `<stdio.h>` speichert den aktuellen Positionszustand eines offenen Datenstroms im von `pos` bezeichneten `fpos_t`-Objekt. Es liefert null bei Erfolg und einen Wert ungleich null bei Fehler; der Zustand ist für späteres `fsetpos` bestimmt.
Mittlere Stufe · C23C`fgets(s, n, stream)` aus `<stdio.h>` liest höchstens `n - 1` Zeichen in das Array `s` und stoppt nach einem gelesenen Zeilenumbruch oder am Dateiende. Ein gelesener Zeilenumbruch bleibt im Array, danach fügt die Funktion `\0` an.
Grundlagen · C23C`floor(x)` aus `<math.h>` liefert den größten ganzzahligen Gleitkommawert, der nicht größer als `x` ist; der Ergebnistyp bleibt `double`. `floorf` und `floorl` bedienen `float` und `long double`, unabhängig von der Rundungsrichtung der Umgebung.
Grundlagen · C23