Array variabler Länge (VLA) in C
Ein lokaler Puffer `int tmp[n]` erhält seine Länge zur Laufzeit. Prüfe die Länge vor der Deklaration und beachte die Lebensdauer sowie die optionale Unterstützung für automatische VLAs in C23.
CKTIS / Wissensdatenbank
Syntax, Operatoren und Programmierkonzepte. Finde eine Erklärung, sieh dir ein Beispiel an und lerne weiter.
Ein lokaler Puffer `int tmp[n]` erhält seine Länge zur Laufzeit. Prüfe die Länge vor der Deklaration und beachte die Lebensdauer sowie die optionale Unterstützung für automatische VLAs in C23.
Deklariere Funktionszeiger, lies die Bedeutung der Klammern und erkenne Funktionen, die solche Zeiger zurückgeben.
Der unäre Operator * bezeichnet das Objekt oder die Funktion, auf das beziehungsweise die ein Zeiger zeigt. Er erzeugt kein Objekt und reserviert keinen Speicher.
Die Funktion abort() aus <stdlib.h> leitet eine abnormale Programmbeendigung ein und kehrt niemals zu ihrem Aufrufer zurück.
Die Funktion abs aus <stdlib.h> gibt den Absolutwert als int zurück. Der Aufruf abs(INT_MIN) führt zu undefiniertem Verhalten.
Die Funktion acos aus <math.h> berechnet den Hauptwert des Arkuskosinus eines Arguments vom Typ double. Das Ergebnis ist ein Winkel im Bogenmaß, nicht in Grad.
Die Funktion acosh aus <math.h> berechnet den nichtnegativen inversen hyperbolischen Kosinus. Sie nimmt einen double-Wert entgegen und gibt einen double-Wert zurück; ein Argument kleiner als 1 verursacht einen Definitionsbereichsfehler.
aligned_alloc reserviert nicht initialisierten Speicher mit der angeforderten Ausrichtung. Prüfen Sie, ob das Ergebnis NULL ist, und geben Sie den Speicher mit free frei.
asctime wandelt eine struct tm in Text mit festem Format um. In C23 ist die Funktion veraltet und sollte in neuem Code vermieden werden.
Die Funktion asin aus <math.h> berechnet den Hauptwert des Arkussinus eines double-Arguments und gibt einen Winkel im Bogenmaß zurück.
asinh aus <math.h> berechnet den inversen hyperbolischen Sinus eines Arguments vom Typ double und gibt einen Wert vom Typ double zurück. Der mathematische Definitionsbereich umfasst alle reellen Zahlen.
Das Makro `assert(...)` aus `<assert.h>` prüft einen skalaren Ausdruck: wahr bewirkt nichts, falsch gibt Diagnoseinformation aus und ruft `abort()` auf. Es liefert keinen Wert.
`atan(double x)` aus `<math.h>` liefert den Hauptwert des Arkustangens im Bogenmaß im Intervall von `-π/2` bis `π/2`; alle reellen Zahlen gehören zum Definitionsbereich.
`atan2(double y, double x)` aus `<math.h>` liefert den Richtungswinkel des Punktes `(x, y)` zur positiven x-Achse im Bogenmaß im Intervall von `-π` bis `π`. Die Argumentreihenfolge ist zuerst `y`, dann `x`.
`atanh(double x)` aus `<math.h>` liefert den reellen Hauptwert des inversen hyperbolischen Tangens. Für ein endliches reelles Ergebnis muss das Argument im offenen Intervall `(-1, 1)` liegen.
`atexit(void (*func)(void))` aus `<stdlib.h>` registriert eine argumentlose Funktion für die normale Programmbeendigung. Sie liefert null bei Erfolg und einen von null verschiedenen Wert, wenn die Registrierung scheitert.
`atof(const char *nptr)` aus `<stdlib.h>` wandelt den Anfang einer Zeichenkette in `double` um; die Funktion arbeitet wie `strtod(nptr, NULL)`, bietet aber weder einen nützlichen Endzeiger noch verlässliche Fehlerdiagnose.
`atoi(const char *nptr)` aus `<stdlib.h>` wandelt eine anfängliche dezimale Ganzzahl einer Zeichenkette um und liefert `int`. Die Funktion überspringt führenden Leerraum, erkennt ein optionales Vorzeichen und endet am ersten unpassenden Zeichen.
`atol(const char *nptr)` aus `<stdlib.h>` liest eine anfängliche dezimale Ganzzahl und liefert `long int`. Führender Leerraum wird übersprungen, ein Vorzeichen akzeptiert und am ersten fremden Zeichen angehalten.
`atoll(const char *nptr)` aus `<stdlib.h>` wandelt eine anfängliche dezimale Ganzzahl um und liefert `long long int`. Führender Leerraum wird übersprungen, ein optionales Vorzeichen erkannt und am ersten unpassenden Zeichen beendet.
`atomic_compare_exchange_strong(object, expected, desired)` aus `<stdatomic.h>` vergleicht atomar das atomare `*object` mit dem nicht atomaren `*expected`. Bei Gleichheit speichert sie `desired` im Objekt und liefert `true`; andernfalls schreibt sie den aktuellen Objektwert nach `*expected` und liefert ohne fälschliches Scheitern `false`.
`atomic_compare_exchange_weak(object, expected, desired)` besitzt dieselbe Erfolgsspeicherung und Aktualisierung von `*expected` bei Misserfolg wie `strong`, darf aber selbst bei gleichen Werten fälschlich `false` liefern. Das Read-Modify-Write auf `object` bleibt atomar; das Schreiben nach `expected` bei Misserfolg ist ein gewöhnlicher nicht atomarer Schreibzugriff.
`atomic_exchange(object, desired)` aus `<stdatomic.h>` führt eine atomare Read-Modify-Write-Operation aus: Sie speichert `desired` in `*object` und liefert den Wert, den das Objekt unmittelbar vor dem Austausch hatte.
`atomic_fetch_add(object, operand)` aus `<stdatomic.h>` addiert `operand` atomar zu einem atomaren Ganzzahl- oder Zeigerobjekt und liefert den Wert vor der Addition. Es handelt sich um eine Read-Modify-Write-Operation.