Konstanten in C: const, #define und enum

Eine Konstante ist ein Wert mit einem Namen und dem Versprechen, dass er sich nicht ändert. C gibt dir drei Mechanismen dafür, und unter der Haube sind sie wirklich verschiedene Dinge - einer ist eine Variable, einer ist Textersetzung und einer ist ein Ganzzahltyp.

Warum einem Wert überhaupt einen Namen geben

Vergleiche diese beiden Zeilen:

double area = 3.14159 * r * r;
double area = PI * r * r;

Die zweite ist aus drei Gründen besser, die sich alle später zeigen. Sie sagt, was die Zahl bedeutet. Sie steht an genau einer Stelle, das Ändern der Genauigkeit ist also eine Bearbeitung statt einer Suche. Und ein Tippfehler in PI ist ein Übersetzungsfehler, während ein Tippfehler in 3.14195 eine falsche Antwort ist.

Unbenannte Zahlen, die über den Code verstreut sind, heißen magische Zahlen, und sie zu entfernen ist eine der billigsten Verbesserungen, die du an einem C-Programm vornehmen kannst.

const

Das Schlüsselwort const markiert eine Variable als nur lesbar:

#include <stdio.h>

int main(void) {
    const double PI = 3.14159265358979;
    const int MAX_USERS = 100;

    double r = 2.0;
    printf("Flaeche bei r=%.1f: %.4f\n", r, PI * r * r);
    printf("Kapazitaet: %d Nutzer\n", MAX_USERS);

    /* PI = 3.0;  <- kommentiere diese Zeile ein und das Programm kompiliert nicht */
    return 0;
}

Kommentiere die Zuweisung ein, und der Compiler verweigert sich: assignment of read-only variable 'PI'. Dieser Fehler zur Bauzeit ist der ganze Sinn.

Eine const-Variable ist eine echte Variable. Sie hat einen Typ, der Compiler prüft also, wie du sie benutzt. Sie gehorcht dem Gültigkeitsbereich, ein const innerhalb einer Funktion dringt also nicht nach außen. Sie hat eine Adresse, du kannst also einen Zeiger darauf nehmen. Und ein Debugger kann dir ihren Namen und Wert zeigen.

const muss an der Stelle der Deklaration initialisiert werden - eine zweite Gelegenheit gibt es nicht:

const int limit;       /* Fehler (oder für immer Müll): später kann nichts zuweisen */
const int limit = 50;  /* korrekt */

#define

Die Alternative des Präprozessors ist ein Makro:

#include <stdio.h>

#define PI 3.14159265358979
#define MAX_USERS 100
#define GREETING "Willkommen im System"

int main(void) {
    double r = 2.0;
    printf("%s\n", GREETING);
    printf("Flaeche bei r=%.1f: %.4f\n", r, PI * r * r);
    printf("Kapazitaet: %d Nutzer\n", MAX_USERS);
    return 0;
}

Das ist keine Variable. Bevor der Compiler läuft, ersetzt der Präprozessor jedes Vorkommen von PI im Quelltext durch die Zeichen 3.14159265358979. Der Compiler sieht den Namen überhaupt nie - genau deshalb hat ein #define keinen Typ und kann in keinem Debugger auftauchen.

Beachte: kein Semikolon und kein =. Ein Makro ist roher Text, dieser häufige Fehler:

#define MAX_USERS 100;        /* beachte das Semikolon */

int limit = MAX_USERS + 1;    /* expandiert zu: int limit = 100; + 1;  -> Fehler */

erzeugt also einen Fehler in einer Zeile, die der Definition überhaupt nicht ähnelt. Die Konvention, Makros groß zu schreiben, existiert genau deshalb, damit Leser wissen, dass hier eine Ersetzung passiert.

Makros werden konventionell in GROSSBUCHSTABEN geschrieben; const-Variablen folgen dem meist ebenfalls, wenn sie für dieselbe Idee stehen.

Enum-Konstanten

Die dritte Form gibt dir einen Satz benannter Ganzzahlen:

#include <stdio.h>

enum { MAX_USERS = 100, BUFFER_SIZE = 256 };

enum Weekday { MON, TUE, WED, THU, FRI };

int main(void) {
    char buffer[BUFFER_SIZE];   /* eine echte Konstante zur Uebersetzungszeit */

    printf("Der Puffer fasst %zu Bytes\n", sizeof(buffer));
    printf("MAX_USERS = %d\n", MAX_USERS);

    enum Weekday today = WED;
    printf("MON=%d TUE=%d WED=%d, heute=%d\n", MON, TUE, WED, today);
    return 0;
}

Die Werte beginnen bei 0 und steigen um eins, sofern du sie nicht zuweist, MON ist also 0 und FRI ist 4. Ein anonymes enum { ... } ist ein verbreitetes Idiom für schlichte Ganzzahlkonstanten.

Enum-Konstanten haben gegenüber beiden Alternativen einen echten Vorteil: Sie sind Ganzzahlkonstanten zur Übersetzungszeit, die der Compiler versteht, und sie sind für den Debugger sichtbar. Die ganze Geschichte steht unter Enums in C.

Welche man nimmt

Die Voreinstellung sollte const sein. Greife zu #define, wenn der Wert vor der Übersetzung existieren muss, und zu enum, wenn du eine Ganzzahl zur Übersetzungszeit oder eine benannte Gruppe brauchst.

Die eine Stelle, an der das wirklich beißt, sind Arraygrößen:

#include <stdio.h>

#define DEFINED_SIZE 5
enum { ENUM_SIZE = 5 };

int global_a[DEFINED_SIZE];   /* in Ordnung */
int global_b[ENUM_SIZE];      /* in Ordnung */

int main(void) {
    const int const_size = 5;
    int local[const_size];    /* C99-Array variabler Laenge - hier funktioniert es... */

    for (int i = 0; i < const_size; i++) local[i] = i * i;
    printf("local[4] = %d\n", local[4]);
    printf("global: %zu %zu\n", sizeof(global_a), sizeof(global_b));
    return 0;
}

Ein const int ist in C eine nur lesbare Variable, keine konstante Ausdrucksform zur Übersetzungszeit. Innerhalb einer Funktion akzeptiert C99 int local[const_size], indem es daraus ein Array variabler Länge macht; auf Dateiebene, in einer struct oder als case-Label wird es rundheraus abgelehnt. enum und #define funktionieren überall.

(Das ist einer der echten Unterschiede zu C++, wo ein const int sehr wohl eine konstante Ausdrucksform ist. Code, der zwischen den Sprachen wandert, stolpert darüber.)

const mit Zeigern

const und Zeiger lassen sich auf drei Arten kombinieren, und die Bedeutungen sind nicht austauschbar. Lies die Deklaration vom Namen nach außen:

const char *p;          /* p zeigt auf chars, die nicht verändert werden dürfen */
char * const q;         /* q selbst kann nicht umgehängt werden; die chars dürfen sich ändern */
const char * const r;   /* weder der Zeiger noch die chars dürfen sich ändern */

#include <stdio.h>

int main(void) {
    char text[] = "hallo";

    const char *p = text;
    /* *p = 'H';  <- Fehler: die Daten sind ueber p konstant */
    p = "welt";  /* aber p umzuhaengen ist in Ordnung */
    printf("p zeigt jetzt auf: %s\n", p);

    char * const q = text;
    q[0] = 'H';   /* die Daten ueber q zu aendern ist in Ordnung */
    /* q = "welt";  <- Fehler: q selbst ist const */
    printf("text ist jetzt: %s\n", text);
    return 0;
}

Die Form const char * ist die, die du am häufigsten schreiben wirst, denn sie ist der richtige Typ für einen Funktionsparameter, der eine Zeichenkette liest, ohne sie zu ändern:

#include <stdio.h>

/* Das const verspricht dem Aufrufer: diese Funktion aendert deine Zeichenkette nicht. */
size_t count_vowels(const char *s) {
    size_t n = 0;
    for (size_t i = 0; s[i] != '\0'; i++) {
        char c = s[i];
        if (c=='a'||c=='e'||c=='i'||c=='o'||c=='u') n++;
    }
    return n;
}

int main(void) {
    printf("Vokale in \"programming\": %zu\n", count_vowels("programming"));
    return 0;
}

Einem nur lesenden Parameter ein const hinzuzufügen kostet nichts und dokumentiert den Vertrag auf eine Art, die der Compiler durchsetzt. Es lohnt sich überall.

Zeichenkettenliterale sind faktisch const

Eine subtile Falle, die const abfangen soll:

char *s = "hallo";   /* gültiges C, aber s zeigt in nur lesbaren Speicher */
s[0] = 'H';          /* undefiniertes Verhalten - meist ein Absturz */

Zeichenkettenliterale liegen in einem nur lesbaren Abschnitt der ausführbaren Datei. Über diesen Zeiger zu schreiben führt typischerweise zu einem Segfault. Den Zeiger als const char *s = "hallo"; zu deklarieren lässt den Compiler die Zuweisung zurückweisen, statt sie zur Laufzeit abstürzen zu lassen.

Wenn du eine veränderbare Zeichenkette brauchst, kopiere sie in ein Array:

#include <stdio.h>

int main(void) {
    const char *literal = "hallo";   /* nur lesbar, kann nicht geaendert werden */
    char copy[] = "hallo";           /* ein Array: eine eigene, aenderbare Kopie */

    copy[0] = 'H';
    printf("Literal: %s\n", literal);
    printf("Kopie:   %s\n", copy);
    return 0;
}