Variablen in C: deklarieren, initialisieren und zuweisen

Eine Variable ist ein benanntes Stück Speicher, das einen Wert hält, den dein Programm lesen und ändern kann. In C sagst du immer vorab, welche Art von Wert sie hält, und diese Wahl ist für die Lebensdauer der Variablen endgültig.

Eine Variable deklarieren

Die Form ist Typ, Name, Semikolon:

int age;
double price;
char grade;

Jede Zeile reserviert genug Speicher für diesen Datentyp und hängt einen Namen daran. Es wurde noch nichts gespeichert - der Platz existiert, aber sein Inhalt ist das, was dort von dem übrig blieb, was vorher lief.

Du kannst im selben Moment einen Wert geben, und das heißt Initialisierung:

#include <stdio.h>

int main(void) {
    int age = 30;
    double price = 19.99;
    char grade = 'A';

    printf("Alter: %d\n", age);
    printf("Preis: %.2f\n", price);
    printf("Note: %c\n", grade);
    return 0;
}

Beachte die Formatangaben: %d für int, %f für double, %c für char. printf prüft die übergebenen Werte nicht - es vertraut deiner Formatzeichenkette, eine Fehlpaarung gibt also Unsinn aus statt eines Fehlers.

Zuweisen nach der Deklaration

Sobald eine Variable existiert, änderst du sie mit =:

#include <stdio.h>

int main(void) {
    int score;      /* deklariert, Wert unbekannt */

    score = 0;      /* Zuweisung */
    printf("Start:  %d\n", score);

    score = 85;     /* erneut zuweisen - der alte Wert ist fort */
    printf("Mitte:  %d\n", score);

    score = score + 10;   /* den alten Wert lesen, den neuen speichern */
    printf("Ende:   %d\n", score);
    return 0;
}

= ist in C die Zuweisung, keine Gleichheit. score = score + 10 liest sich als „nimm, was in score steht, addiere 10, lege das Ergebnis zurück in score". Der Vergleichsoperator ist ==, und die beiden zu verwechseln ist ein so häufiger Bug, dass er auf der Seite Booleans einen eigenen Abschnitt hat.

Die Kurzform score += 10 tut dasselbe mit weniger Zeichen; die zusammengesetzten Zuweisungsoperatoren decken die ganze Arithmetik ab.

Die Falle der uninitialisierten Variablen

Das ist der mit Abstand häufigste Anfängerfehler in C, und er erzeugt keinen Fehler:

#include <stdio.h>

int main(void) {
    int total;      /* bekam nie einen Wert */

    for (int i = 1; i <= 5; i++) {
        total += i; /* total lesen, bevor es einen Wert hat */
    }

    printf("Summe: %d\n", total);
    return 0;
}

Führe es aus. Du siehst womöglich 15, die richtige Antwort. Du siehst womöglich eine riesige Zufallszahl. Du siehst womöglich bei einem zweiten Lauf oder auf einer anderen Maschine etwas anderes. All das ist „korrektes" Verhalten, denn eine uninitialisierte lokale Variable zu lesen ist undefiniertes Verhalten - der C-Standard stellt keine Anforderung daran, was passiert.

Anders als viele Sprachen nullt C deine Lokalen nicht. Eine lokale Variable ist ein Stück Stack, und der Stack ist voller Überreste früherer Funktionsaufrufe. Manchmal sind diese Überreste zufällig null, und das macht diesen Bug so gefährlich: Er funktioniert oft im Test und scheitert in der Produktion.

Die Lösung ist ein Zeichen:

#include <stdio.h>

int main(void) {
    int total = 0;      /* initialisiert */

    for (int i = 1; i <= 5; i++) {
        total += i;
    }

    printf("Summe: %d\n", total);
    return 0;
}

Mach es zur Gewohnheit: Initialisiere jede Variable an der Stelle der Deklaration. Wenn du wirklich noch keinen sinnvollen Wert hast, sind 0 oder NULL besser als Müll. Und kompiliere mit -Wall, das die meisten Fälle abfängt:

warning: 'total' is used uninitialized in this function

Globale und static-Variablen sind die Ausnahme - sie werden automatisch mit null initialisiert. Sich darauf zu verlassen ist in Ordnung, aber = 0 trotzdem zu schreiben dokumentiert deine Absicht.

Mehrere auf einmal deklarieren

Variablen desselben Typs dürfen sich eine Deklaration teilen, mit oder ohne Initialisierer:

#include <stdio.h>

int main(void) {
    int x = 1, y = 2, z = 3;
    double width = 4.5, height;   /* height ist uninitialisiert */

    height = 2.0;
    printf("%d %d %d\n", x, y, z);
    printf("Flaeche: %.2f\n", width * height);
    return 0;
}

Das ist erlaubt und bei eng verwandten Werten wie x, y, z verbreitet. Hier wohnt auch ein klassisches Missverständnis:

int a = 0, b = 0, c = 0;   /* alle drei sind 0 */
int d, e, f = 0;           /* nur f ist 0 - d und e sind Müll */

Der Initialisierer hängt an einem Namen, nicht an der Zeile. Wenn die Werte sich in ihrer Bedeutung unterscheiden, gib jedem eine eigene Zeile - das liest sich besser und lässt sich besser vergleichen.

Zeiger in einer Zeile zu deklarieren hat dieselbe Falle in schärferer Form:

int *p, q;   /* p ist ein Zeiger auf int; q ist ein schlichtes int */

Das * bindet an den Namen, nicht an den Typ. Deklariere Zeiger einen pro Zeile.

Namensregeln und Konventionen

Die Regeln des Compilers:

• Nur Buchstaben, Ziffern und Unterstriche.
• Darf nicht mit einer Ziffer beginnen: total2 ist in Ordnung, 2total nicht.
• Darf kein C-Schlüsselwort sein: keine Variable namens int, return, for, double.
• Groß-/Kleinschreibung zählt: count, Count und COUNT sind drei verschiedene Variablen.
• Namen, die mit einem Unterstrich beginnen oder einen doppelten Unterstrich enthalten, sind für die Implementierung reserviert. Erzeuge sie nicht.

int itemCount;       /* erlaubt */
int item_count;      /* erlaubt - der übliche C-Stil */
int _count;          /* erlaubt, aber reserviert - vermeiden */
int item-count;      /* Fehler: '-' ist der Minusoperator */
int 3rd_place;       /* Fehler: beginnt mit einer Ziffer */
int float;           /* Fehler: Schlüsselwort */

Die Konventionen, denen der meiste C-Code folgt: snake_case für Variablen und Funktionen, GROSSBUCHSTABEN für Makrokonstanten, und Namen, die sagen, was der Wert bedeutet, statt welchen Typ er hat. elapsed_ms schlägt t; customer_count schlägt n2.

Kurze Namen sind weiterhin in Ordnung, wo der Gültigkeitsbereich winzig ist - i als Schleifenzähler versteht jeder, und niemand will for (int loop_iteration_index = 0; ...).

Wo eine Variable lebt

Wo du eine Variable deklarierst, bestimmt, wer sie sehen kann und wie lange sie hält. Das ist der Gültigkeitsbereich, und die Kurzfassung lautet:

#include <stdio.h>

int shared = 100;       /* global: fuer jede Funktion dieser Datei sichtbar */

void show(void) {
    printf("show sieht shared = %d\n", shared);
}

int main(void) {
    int local = 5;      /* lokal zu main */

    {
        int inner = 7;  /* nur lokal zu diesem Block */
        printf("inner = %d, local = %d\n", inner, local);
    }
    /* inner existiert hier nicht mehr */

    show();
    printf("main sieht local = %d\n", local);
    return 0;
}

Eine Variable ist von ihrer Deklaration bis zur schließenden Klammer des sie enthaltenden Blocks sichtbar. Globale leben für das ganze Programm und sind überall sichtbar, was bequem klingt und der Grund ist, warum sie Ärger machen: Jede Funktion kann eine ändern, herauszufinden, wer es tat, wird also zur Suche durch die ganze Datei. Bevorzuge Lokale und übergib Werte als Parameter an Funktionen.

Überall deklarieren (C99 und später)

Im ursprünglichen C89 musste jede Deklaration vor jeder Anweisung eines Blocks stehen:

int main(void) {
    int i, sum = 0;      /* alle Deklarationen zuerst */
    printf("Starte\n");
    for (i = 0; i < 10; i++) { sum += i; }
    return 0;
}

Seit C99 darfst du dort deklarieren, wo du den Wert zuerst brauchst, auch im for-Kopf:

#include <stdio.h>

int main(void) {
    printf("Starte\n");

    int sum = 0;                          /* dort deklariert, wo es gebraucht wird */
    for (int i = 0; i < 10; i++) {        /* i gilt nur in der Schleife */
        sum += i;
    }

    printf("Summe: %d\n", sum);
    return 0;
}

Das ist der bessere Stil: Die Deklaration sitzt neben ihrer ersten Verwendung, und i kann nicht in den Rest der Funktion durchsickern. Kompiliere mit -std=c17 (oder einer beliebigen C99+-Einstellung), und es funktioniert überall.