C Academy · Lektion

Fragen der Typsicherheit

Risiken von variadischen Funktionen

Fragen der Typsicherheit ist eine kostenlose C Academy-Lektion auf CoddyKit. Dies ist Lektion 3 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des C Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der C Academy-Kurs umfasst insgesamt 4 Lektionen.

Variadics umgehen die Typprüfung

Normale C-Funktionen prüfen, ob Argumente zu den Parametertypen passen. Variadische Argumente umgehen diese Prüfung vollständig.

Der Compiler kann nicht überprüfen, was Sie nach dem ... übergeben, wodurch Fehler leicht entstehen und gefährlich werden.

#include <stdio.h>
#include <stdarg.h>

int add(int n, ...) {
    va_list a; va_start(a, n);
    int s = 0;
    for (int i = 0; i < n; i++) s += va_arg(a, int);
    va_end(a);
    return s;
}

int main(void) {
    printf("%d\n", add(2, 3, 4));
    return 0;
}

Falscher Typ in va_arg

Wenn Sie ein Argument mit dem falschen Typ lesen, ist das Ergebnis undefiniertes Verhalten.

Wenn Sie ein int übergeben, es aber als double lesen, werden nicht zusammengehörige Bytes fehlinterpretiert, was zu Datenmüll oder einem Absturz führt.

#include <stdio.h>
#include <stdarg.h>

int read_int(int n, ...) {
    va_list a; va_start(a, n);
    int v = va_arg(a, int);
    va_end(a);
    return v;
}

int main(void) {
    printf("%d\n", read_int(1, 100));
    return 0;
}

Nicht übereinstimmende Format-Strings

Bei Funktionen im printf-Stil ist ein falscher Bezeichner ein klassischer Fehler. printf("%d", 3.14) liest ein double, als wäre es ein int.

Moderne Compiler warnen bei Nichtübereinstimmungen in Literalen, können aber zur Laufzeit erstellte Format-Strings nicht erkennen.

#include <stdio.h>

int main(void) {
    double pi = 3.14;
    printf("%f\n", pi);
    return 0;
}

Überraschungen bei Integer-Promotions

Kleine Typen werden im variadischen Teil zu int promoviert. Selbst wenn Sie also ein char übergeben, müssen Sie es wieder als int lesen.

Das Lesen als char mit va_arg(a, char) ist undefiniert.

#include <stdio.h>
#include <stdarg.h>

void show(int n, ...) {
    va_list a; va_start(a, n);
    int c = va_arg(a, int);
    printf("char is %c\n", c);
    va_end(a);
}

int main(void) {
    show(1, 'A');
    return 0;
}

Float wird zu double

Ein float-Argument wird bei Variadics immer zu double promoviert. Sie müssen es als double lesen, niemals als float.

Dies ist einer der häufigsten Fehler bei Variadics.

#include <stdio.h>
#include <stdarg.h>

void show(int n, ...) {
    va_list a; va_start(a, n);
    double d = va_arg(a, double);
    printf("%.2f\n", d);
    va_end(a);
}

int main(void) {
    float f = 1.5f;
    show(1, f);
    return 0;
}

Zu viele Argumente lesen

Wenn Ihr Code va_arg häufiger aufruft, als der Aufrufer Argumente übergeben hat, lesen Sie Datenmüll vom Stack.

Deshalb ist eine korrekte Anzahl oder ein Sentinel unerlässlich.

#include <stdio.h>
#include <stdarg.h>

int sum(int n, ...) {
    va_list a; va_start(a, n);
    int s = 0;
    for (int i = 0; i < n; i++) s += va_arg(a, int);
    va_end(a);
    return s;
}

int main(void) {
    printf("%d\n", sum(3, 1, 2, 3));
    return 0;
}

Bei NULL-Pointer-Sentinels vorsichtig sein

Die Verwendung von NULL als Sentinel ist riskant: Auf manchen Plattformen ist NULL ein int mit dem Wert 0, dessen Größe sich von der eines Pointers unterscheidet.

Wandeln Sie den Wert explizit um, etwa mit (char *)NULL, damit der richtige Typ übergeben wird.

#include <stdio.h>
#include <stdarg.h>

void print_all(const char *first, ...) {
    va_list a; va_start(a, first);
    const char *s = first;
    while (s) { printf("%s\n", s); s = va_arg(a, const char *); }
    va_end(a);
}

int main(void) {
    print_all("a", "b", (char *)NULL);
    return 0;
}

Format-Attribute des Compilers

GCC und Clang bieten __attribute__((format(printf, 1, 2))), um dem Compiler mitzuteilen, dass Ihre Funktion die Formatierung im printf-Stil verwendet.

Der Compiler prüft dann Ihre Format-Strings zur Compilezeit und findet viele Fehler.

#include <stdio.h>
#include <stdarg.h>

void logf(const char *fmt, ...)
    __attribute__((format(printf, 1, 2)));

void logf(const char *fmt, ...) {
    va_list a; va_start(a, fmt);
    vprintf(fmt, a);
    va_end(a);
}

int main(void) {
    logf("%d items\n", 3);
    return 0;
}

Sicherere Alternativen bevorzugen

Da Variadics fehleranfällig sind, sollten Sie nach Möglichkeit typsichere Entwürfe bevorzugen: Übergeben Sie ein explizites Array, eine Struktur oder feste Parameter.

Verwenden Sie Variadics nur für tatsächliche Anforderungen im Stil von printf.

#include <stdio.h>

int sum_array(const int *a, int n) {
    int s = 0;
    for (int i = 0; i < n; i++) s += a[i];
    return s;
}

int main(void) {
    int nums[] = {1, 2, 3, 4};
    printf("%d\n", sum_array(nums, 4));
    return 0;
}

Den Vertrag dokumentieren

Da der Compiler variadische Typen nicht erzwingen kann, ist eine klare Dokumentation Ihr Sicherheitsnetz.

Geben Sie genau an, welche Typen und wie viele Argumente der Aufrufer übergeben muss und wie die Liste endet.

#include <stdio.h>
#include <stdarg.h>

/* sum_ints(n, ...): pass exactly n int values */
int sum_ints(int n, ...) {
    va_list a; va_start(a, n);
    int s = 0;
    for (int i = 0; i < n; i++) s += va_arg(a, int);
    va_end(a);
    return s;
}

int main(void) {
    printf("%d\n", sum_ints(2, 5, 5));
    return 0;
}

Gründlich testen

Da sich Fehler unbemerkt verbergen können, testen Sie variadische Funktionen mit vielen verschiedenen Argumentanzahlen und -typen.

Grenzfälle wie null Argumente oder die maximale Anzahl bringen Fehler oft ans Licht.

#include <stdio.h>
#include <stdarg.h>

int sum(int n, ...) {
    va_list a; va_start(a, n);
    int s = 0;
    for (int i = 0; i < n; i++) s += va_arg(a, int);
    va_end(a);
    return s;
}

int main(void) {
    printf("%d\n", sum(0));
    printf("%d\n", sum(1, 9));
    return 0;
}

Kurzer Test

Testen Sie Ihr Verständnis der Risiken variadischer Typen.

Zusammenfassung

Sie haben die Gefahren variadischer Funktionen kennengelernt:

Der Compiler führt für variadische Argumente keine Typprüfung durch.
Falsche Typen, falsche Anzahlen und fehlerhafte Sentinels verursachen undefiniertes Verhalten.
Denken Sie an die Promotions: kleine Ganzzahlen zu int, float zu double.
Verwenden Sie Format-Attribute des Compilers, dokumentieren Sie den Vertrag und bevorzugen Sie nach Möglichkeit typsichere Alternativen.

Häufig gestellte Fragen

Ist die Lektion „Fragen der Typsicherheit“ kostenlos?

Ja — der vollständige Text von „Fragen der Typsicherheit“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des C Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der C Academy-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „Fragen der Typsicherheit“?

Risiken von variadischen Funktionen Du übst C Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um C Academy zu starten?

Keine Vorkenntnisse erforderlich. C Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 3 von 4.

Wie lange dauert die Lektion „Fragen der Typsicherheit“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser C Academy-Lektion Code schreiben und ausführen?

Ja. Jede C Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

← Zurück zu C Academy