C`iscntrl(c)` aus `<ctype.h>` liefert einen Wert ungleich null, wenn `c` im aktuellen Gebietsschema ein Steuerzeichen ist. Ein Steuerzeichen ist nicht druckbar; im anfänglichen `C`-Gebietsschema gehören Zeilenumbruch und horizontaler Tabulator zu dieser Klasse.
Grundlagen · C23C`isdigit(c)` aus `<ctype.h>` prüft, ob `c` eine Dezimalziffer des Basis-Ausführungszeichensatzes ist, also eines der Zeichen `0` bis `9`. Für eine Ziffer liefert es einen Wert ungleich null, für jedes andere gültige Argument null.
Grundlagen · C23C`isfinite(x)` aus `<math.h>` ist ein Klassifikationsmakro: Es liefert genau dann einen Wert ungleich null, wenn sein reelles Gleitkommaargument endlich ist. Normale und subnormale Zahlen sowie beide vorzeichenbehafteten Nullen sind endlich; Unendlichkeiten und NaNs nicht.
Grundlagen · C23C`isgraph(c)` aus `<ctype.h>` liefert für ein druckbares Zeichen außer Leerzeichen im aktuellen Gebietsschema einen Wert ungleich null. Es umfasst somit Zeichen mit sichtbarer Markierung wie Buchstaben, Ziffern und Interpunktion, nicht aber Abstand und Steuerzeichen.
Grundlagen · C23C`isinf(x)` aus `<math.h>` ist ein Klassifikationsmakro, das genau dann einen Wert ungleich null liefert, wenn sein reelles Gleitkommaargument positive oder negative Unendlichkeit ist. Endliche Werte und jedes NaN ergeben null.
Grundlagen · C23C`islower(c)` aus `<ctype.h>` liefert einen Wert ungleich null, wenn `c` im aktuellen Gebietsschema ein Kleinbuchstabe ist. Im `C`-Gebietsschema umfasst dies mindestens `a` bis `z`; ein anderes Gebietsschema kann weitere einbyteige Buchstaben klassifizieren.
Grundlagen · C23C`isnan(x)` aus `<math.h>` ist ein Klassifikationsmakro, das genau dann einen Wert ungleich null liefert, wenn sein reelles Gleitkommaargument NaN ist. Endliche Werte und beide Unendlichkeiten ergeben null.
Grundlagen · C23C`isprint(c)` aus `<ctype.h>` liefert für ein druckbares Zeichen im aktuellen Gebietsschema einen Wert ungleich null. Anders als `isgraph` umfasst es auch das Leerzeichen; Steuerzeichen wie Zeilenumbruch und horizontaler Tabulator sind nicht druckbar.
Grundlagen · C23C`ispunct(c)` aus `<ctype.h>` liefert für ein Satzzeichen einen Wert ungleich null: ein druckbares Zeichen, das im aktuellen Gebietsschema weder Leerzeichen noch alphanumerisch ist. Unterstrich ist Interpunktion, obwohl C ihn in Bezeichnern erlaubt.
Grundlagen · C23C`isspace(c)` aus `<ctype.h>` liefert für ein Leerraumzeichen im aktuellen Gebietsschema einen Wert ungleich null. Im `C`-Gebietsschema umfasst die Klasse Leerzeichen, `\f`, `\n`, `\r`, `\t` und `\v` und ist damit breiter als das horizontale `isblank`.
Grundlagen · C23C`isupper(c)` aus `<ctype.h>` liefert einen Wert ungleich null, wenn `c` im aktuellen Gebietsschema ein Großbuchstabe ist; im Gebietsschema `C` gilt das für `A` bis `Z`. Das Ergebnis ist nur logisch ungleich null und nicht zwingend genau `1`.
Grundlagen · C23C`isxdigit(c)` aus `<ctype.h>` liefert für eine Hexadezimalziffer ungleich null: `0`–`9`, `A`–`F` oder `a`–`f`. Es klassifiziert ein Zeichen und parst weder ein ganzes Literal noch dessen Präfix `0x`.
Grundlagen · C23C`labs(j)` aus `<stdlib.h>` liefert den Absolutwert eines Arguments vom Typ `long int`. Das Ergebnis ist ebenfalls `long int`; die Funktion parst keinen Text und meldet keinen Fehler über `errno`.
Grundlagen · C23C`ldexp(x, exp)` aus `<math.h>` liefert `x * 2^exp`; `ldexpf` und `ldexpl` bedienen `float` und `long double`. Die Skalierung erfolgt somit unabhängig von `FLT_RADIX` mit einer ganzzahligen Zweierpotenz.
Mittlere Stufe · C23C`ldiv(numer, denom)` aus `<stdlib.h>` berechnet Quotient und Rest vom Typ `long int` in einer Operation und liefert `ldiv_t` mit `quot` und `rem`. Die Division schneidet gegen null ab, und `numer == quot * denom + rem`.
Grundlagen · C23C`llabs(j)` aus `<stdlib.h>` liefert den Absolutwert eines `long long int` mit demselben Ergebnistyp. Die Funktion parst keinen Text und setzt `errno` nicht.
Grundlagen · C23C`lldiv(numer, denom)` aus `<stdlib.h>` berechnet Quotient und Rest als `long long int` und liefert `lldiv_t` mit `quot` und `rem`. Die Division schneidet gegen null ab, und `numer == quot * denom + rem`.
Grundlagen · C23C`llround(x)` aus `<math.h>` rundet auf den nächsten `long long int`; ein exakter Halbfall wird unabhängig vom aktuellen Gleitkomma-Rundungsmodus immer von null weg gerundet.
Mittlere Stufe · C23C`localeconv()` aus `<locale.h>` liefert einen Zeiger auf `struct lconv` mit den aktuellen Zahlen- und Währungsformaten, darunter `decimal_point`, Gruppentrenner und Währungszeichen. Das Gebietsschema wird nicht geändert.
Mittlere Stufe · C23C`localtime(timer)` aus `<time.h>` wandelt den bezeichneten `time_t` in zerlegte lokale Kalenderzeit um und liefert einen Zeiger auf `struct tm`; dabei gelten Zeitzonen- und Sommerzeitregeln der Umgebung. Bei Fehler kann null folgen.
Mittlere Stufe · C23C`log(x)` aus `<math.h>` berechnet den natürlichen Logarithmus eines positiven `x` und liefert `ln(x)` als `double`; `logf` und `logl` bedienen `float` und `long double`. Das Ergebnis ist für `0 < x < 1` negativ, bei `x == 1` null und für `x > 1` positiv.
Grundlagen · C23C`log10(x)` aus `<math.h>` liefert den dekadischen Logarithmus eines positiven `x` als `double`; `log10f` und `log10l` bedienen die anderen Typen. Das Ergebnis nennt die Potenz von `10`, die das Argument ergibt.
Grundlagen · C23C`log1p(x)` aus `<math.h>` berechnet `ln(1 + x)` ohne den Ziffernverlust, der beim getrennten Bilden von `1 + x` für sehr kleines `x` entsteht; `log1pf` und `log1pl` bedienen andere Typen. Der reelle Bereich ist `x >= -1`.
Mittlere Stufe · C23C`log2(x)` aus `<math.h>` liefert den Zweierlogarithmus eines positiven `x`; `log2f` und `log2l` bedienen andere Typen. Zweierpotenzen ergeben ganzzahlige Werte, nützlich für Baumebenen, Blockgrößen und Bit-Analysen.
Grundlagen · C23