Stałe w C: const, #define i enum

Stała to wartość z nazwą i obietnicą, że się nie zmieni. C daje ci do tego trzy mechanizmy, a pod spodem to naprawdę różne rzeczy: jeden jest zmienną, drugi podstawieniem tekstu, a trzeci typem całkowitym.

Po co w ogóle nazywać wartość

Porównaj te dwie linie:

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

Druga jest lepsza z trzech powodów, które wszystkie wychodzą na jaw później. Mówi, co znaczy liczba. Pojawia się w dokładnie jednym miejscu, więc zmiana dokładności to jedna edycja, a nie wyszukiwanie. A literówka w PI to błąd kompilacji, podczas gdy literówka w 3.14195 to błędny wynik.

Nienazwane liczby rozsiane po kodzie nazywa się magicznymi liczbami, a ich usunięcie to jedno z najtańszych ulepszeń, jakie możesz wprowadzić w programie w C.

const

Słowo kluczowe const oznacza zmienną jako tylko do odczytu:

#include <stdio.h>

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

    double r = 2.0;
    printf("Pole dla r=%.1f: %.4f\n", r, PI * r * r);
    printf("Pojemnosc: %d uzytkownikow\n", MAX_USERS);

    /* PI = 3.0;  <- odkomentuj tę linię, a program się nie skompiluje */
    return 0;
}

Odkomentuj przypisanie, a kompilator odmówi: assignment of read-only variable 'PI'. Ten błąd w czasie budowania to cały sens.

Zmienna const to prawdziwa zmienna. Ma typ, więc kompilator sprawdza, jak jej używasz. Respektuje zasięg, więc const wewnątrz funkcji nie wycieka na zewnątrz. Ma adres, więc możesz wziąć do niej wskaźnik. A debugger pokaże ci jej nazwę i wartość.

const musi zostać zainicjalizowane w miejscu deklaracji, bo drugiej szansy nie ma:

const int limit;       /* błąd (albo śmieci na zawsze): nic nie może później nadać mu wartości */
const int limit = 50;  /* poprawnie */

#define

Alternatywą z preprocesora jest makro:

#include <stdio.h>

#define PI 3.14159265358979
#define MAX_USERS 100
#define GREETING "Witaj w systemie"

int main(void) {
    double r = 2.0;
    printf("%s\n", GREETING);
    printf("Pole dla r=%.1f: %.4f\n", r, PI * r * r);
    printf("Pojemnosc: %d uzytkownikow\n", MAX_USERS);
    return 0;
}

To nie jest zmienna. Zanim uruchomi się kompilator, preprocesor zastępuje każde wystąpienie PI w kodzie źródłowym znakami 3.14159265358979. Kompilator w ogóle nie widzi nazwy i właśnie dlatego #define nie ma typu i nie może pojawić się w debuggerze.

Zwróć uwagę, że nie ma średnika ani =. Makro to surowy tekst, więc ten częsty błąd:

#define MAX_USERS 100;        /* zwróć uwagę na średnik */

int limit = MAX_USERS + 1;    /* rozwija się do: int limit = 100; + 1;  -> błąd */

daje błąd w linii, która w niczym nie przypomina definicji. Konwencja pisania makr wielkimi literami istnieje właśnie po to, żeby czytelnik wiedział, że zachodzi podstawienie.

Makra zwyczajowo zapisuje się jako UPPER_CASE; zmienne const zwykle stosują tę samą konwencję, gdy reprezentują tę samą ideę.

Stałe enum

Trzecia forma daje zestaw nazwanych liczb całkowitych:

#include <stdio.h>

enum { MAX_USERS = 100, BUFFER_SIZE = 256 };

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

int main(void) {
    char buffer[BUFFER_SIZE];   /* prawdziwa stała czasu kompilacji */

    printf("bufor miesci %zu bajtow\n", sizeof(buffer));
    printf("MAX_USERS = %d\n", MAX_USERS);

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

Wartości zaczynają się od 0 i rosną o jeden, chyba że je przypiszesz, więc MON to 0, a FRI to 4. Anonimowe enum { ... } to częsty idiom dla zwykłych stałych całkowitych.

Stałe enum mają prawdziwą przewagę nad obiema alternatywami: są stałymi całkowitymi czasu kompilacji, które kompilator rozumie, i są widoczne w debuggerze. Pełną historię znajdziesz w artykule o enumach w C.

Której użyć

Domyślnym wyborem powinno być const. Sięgaj po #define, gdy wartość musi istnieć przed kompilacją, a po enum, gdy potrzebujesz liczby całkowitej czasu kompilacji albo nazwanej grupy.

Jedyne miejsce, w którym to naprawdę gryzie, to rozmiary tablic:

#include <stdio.h>

#define DEFINED_SIZE 5
enum { ENUM_SIZE = 5 };

int global_a[DEFINED_SIZE];   /* w porządku */
int global_b[ENUM_SIZE];      /* w porządku */

int main(void) {
    const int const_size = 5;
    int local[const_size];    /* tablica o zmiennej długości z C99: tutaj działa... */

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

const int w C to zmienna tylko do odczytu, a nie stałe wyrażenie czasu kompilacji. Wewnątrz funkcji C99 akceptuje int local[const_size], robiąc z tego tablicę o zmiennej długości; na poziomie pliku, w struct albo jako etykieta case zostaje to od razu odrzucone. enum i #define działają wszędzie.

(To jedna z prawdziwych różnic w stosunku do C++, gdzie const int jest stałym wyrażeniem. Kod przenoszony między tymi językami się na tym potyka.)

const ze wskaźnikami

const i wskaźniki łączą się na trzy sposoby, a ich znaczenia nie są wymienne. Czytaj deklarację od nazwy na zewnątrz:

const char *p;          /* p wskazuje na znaki, których nie wolno modyfikować */
char * const q;         /* samego q nie można przestawić; znaki mogą się zmieniać */
const char * const r;   /* nie może się zmienić ani wskaźnik, ani znaki */

#include <stdio.h>

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

    const char *p = text;
    /* *p = 'H';  <- błąd: dane są const, gdy patrzy się przez p */
    p = "world";  /* ale przestawienie p jest w porządku */
    printf("p wskazuje teraz na: %s\n", p);

    char * const q = text;
    q[0] = 'H';   /* modyfikowanie danych przez q jest w porządku */
    /* q = "world";  <- błąd: samo q jest const */
    printf("text to teraz: %s\n", text);
    return 0;
}

Formę const char * będziesz pisać najczęściej, bo to właściwy typ dla parametru funkcji, który czyta string, nie zmieniając go:

#include <stdio.h>

/* const obiecuje wywołującemu: ta funkcja nie zmieni twojego stringa. */
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("samogloski w \"programming\": %zu\n", count_vowels("programming"));
    return 0;
}

Dodanie const do parametru tylko do odczytu nic nie kosztuje, a dokumentuje umowę w sposób, który egzekwuje kompilator. Warto to robić wszędzie.

Literały stringowe są w praktyce const

Subtelna pułapka, do której wyłapywania istnieje const:

char *s = "hello";   /* poprawne w C, ale s wskazuje na pamięć tylko do odczytu */
s[0] = 'H';          /* niezdefiniowane zachowanie: zwykle awaria */

Literały stringowe leżą w sekcji pliku wykonywalnego przeznaczonej tylko do odczytu. Zapis przez ten wskaźnik zwykle kończy się segfaultem. Zadeklarowanie wskaźnika jako const char *s = "hello"; sprawia, że kompilator odrzuci przypisanie, zamiast pozwolić programowi wysypać się w czasie działania.

Jeśli potrzebujesz modyfikowalnego stringa, skopiuj go do tablicy:

#include <stdio.h>

int main(void) {
    const char *literal = "hello";   /* tylko do odczytu, nie można go zmieniać */
    char copy[] = "hello";           /* tablica: prywatna, modyfikowalna kopia */

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