Kompilacja warunkowa w C: #ifdef, #ifndef, #if i -D

Kompilacja warunkowa pozwala, żeby jeden plik źródłowy stał się kilkoma różnymi programami. Preprocesor decyduje, zanim uruchomi się kompilator, które bloki tekstu przetrwają, więc kod w niespełnionej gałęzi nie jest po prostu pomijany w czasie działania, tylko usuwany. Nigdy nie jest parsowany, więc nic nie wnosi do pliku wykonywalnego i może nawet zawierać konstrukcje, które bieżący kompilator by odrzucił.

To różnica w stosunku do zwykłego if. Oba wybierają między ścieżkami; tylko jeden wybiera, zanim program w ogóle powstanie.

#ifdef i #ifndef

Najprostsze pytanie brzmi: czy makro w ogóle jest zdefiniowane?

#include <stdio.h>

#define DEBUG

int main(void) {
#ifdef DEBUG
    printf("[debug] wejscie do main\n");
#endif

    int total = 0;
    for (int i = 1; i <= 5; i++) {
        total += i;
#ifdef DEBUG
        printf("[debug] i=%d total=%d\n", i, total);
#endif
    }

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

Usuń linię #define DEBUG, a każde wypisywanie debugowe zniknie z buildu: nie zostanie wyłączone, tylko zniknie. Uruchom program raz w obecnej postaci, potem usuń tę linię i uruchom go ponownie.

#ifndef to zaprzeczenie: zachowaj blok tylko wtedy, gdy makro nie jest zdefiniowane. Najczęściej używa się go w strażnikach dołączania, omówionych przy plikach nagłówkowych, a także do podania wartości domyślnej, którą wywołujący może nadpisać:

#include <stdio.h>

/* Build może to nadpisać przez -DBUFFER_SIZE=512 */
#ifndef BUFFER_SIZE
#define BUFFER_SIZE 128
#endif

int main(void) {
    char buffer[BUFFER_SIZE];
    printf("Bufor miesci %zu bajtow\n", sizeof(buffer));
    return 0;
}

Każde #ifdef i #ifndef musi zostać zamknięte przez #endif. Opisanie zamknięcia w długich plikach, na przykład #endif /* DEBUG */, oszczędza później sporo czasu.

#if, #elif, #else

#if przyjmuje stałe wyrażenie całkowite i zachowuje blok, gdy jest ono niezerowe. To umożliwia porównywanie wersji i poziomów:

#include <stdio.h>

#define LOG_LEVEL 2   /* 0 = cicho, 1 = błędy, 2 = info, 3 = szczegółowo */

int main(void) {
#if LOG_LEVEL >= 3
    printf("szczegolowo: kazdy detal\n");
#endif

#if LOG_LEVEL >= 2
    printf("info: start\n");
#endif

#if LOG_LEVEL >= 1
    printf("raportowanie bledow jest wlaczone\n");
#elif LOG_LEVEL == 0
    printf("(cichy build)\n");
#endif

    return 0;
}

Zmień LOG_LEVEL na 0 albo 3 i uruchom ponownie, żeby zobaczyć, jak zmienia się kształt samego programu.

Wyrażenie oblicza preprocesor, co oznacza, że może ono używać tylko stałych całkowitych, operatorów arytmetycznych i porównania oraz makr, które się do nich rozwijają. Nie widzi sizeof, wartości enum, zmiennych ani niczego, co wymaga kompilatora. Niezdefiniowane makro wewnątrz #if daje 0 zamiast błędu, co jest wygodne, a czasem zaskakujące:

#if FEATURE_X        /* FEATURE_X nigdzie nie jest zdefiniowane -> 0 -> blok odrzucony */

defined(NAME) zamienia pytanie z #ifdef w coś, czego można użyć wewnątrz #if, więc da się łączyć testy:

#if defined(DEBUG) && !defined(NDEBUG)
    /* build debugowy z włączonymi asercjami */
#endif

#if defined(LINUX) || defined(BSD)
    /* dowolny z tych dwóch systemów uniksopodobnych */
#endif

#if defined(X) i #ifdef X znaczą to samo; sięgaj po pierwsze, gdy potrzebujesz &&, || albo !.

Definiowanie makr z wiersza poleceń

Prawdziwa siła tych przełączników polega na tym, że kod źródłowy nie musi się w ogóle zmieniać. gcc -D definiuje makro dla całej kompilacji:

gcc -DDEBUG program.c -o program        # DEBUG zdefiniowane jako 1
gcc -DLOG_LEVEL=3 program.c -o program  # konkretna wartość
gcc -DDEBUG -DBUFFER_SIZE=512 a.c b.c -o app

Samo -DNAME jest równoważne #define NAME 1. -U NAME usuwa definicję, co ma znaczenie, gdy nagłówek definiuje coś, co chcesz wyłączyć.

Typowy układ wygląda więc tak: kod źródłowy zawiera wartości domyślne chronione przez #ifndef, a polecenie budowania wybiera konfigurację.

/* config.h */
#ifndef LOG_LEVEL
#define LOG_LEVEL 1        /* domyślnie cicho */
#endif

#ifndef MAX_CONNECTIONS
#define MAX_CONNECTIONS 64
#endif

# build deweloperski
gcc -DDEBUG -DLOG_LEVEL=3 -Wall -Wextra -g src/*.c -o app-dev

# build produkcyjny
gcc -DNDEBUG -O2 src/*.c -o app

NDEBUG jest ustandaryzowane: jego zdefiniowanie wyłącza każde assert() w programie, bo sam <assert.h> jest napisany z użyciem kompilacji warunkowej. To ten wzorzec w miniaturze: nagłówek, który kompiluje się do różnych rzeczy w zależności od tego, co zdefiniował build.

Przełączniki platformy

Kompilatory predefiniują makra identyfikujące system docelowy, więc jeden plik źródłowy może wywołać właściwe API na każdym z nich:

#if defined(_WIN32)
    #include <windows.h>
    #define CLEAR_SCREEN "cls"
#elif defined(__APPLE__)
    #include <unistd.h>
    #define CLEAR_SCREEN "clear"
#elif defined(__linux__)
    #include <unistd.h>
    #define CLEAR_SCREEN "clear"
#else
    #error "Nieobslugiwana platforma"
#endif

Najczęstsze z nich: _WIN32 (zdefiniowane zarówno w 32-, jak i 64-bitowym Windows), _WIN64, __linux__, __APPLE__, __unix__, __ANDROID__. Tożsamość kompilatora ma własny zestaw (__GNUC__, __clang__, _MSC_VER), podobnie jak architektura (__x86_64__, __aarch64__).

Wersja do uruchomienia, która raportuje, dla czego została zbudowana:

#include <stdio.h>

int main(void) {
#if defined(_WIN32)
    const char *os = "Windows";
#elif defined(__APPLE__)
    const char *os = "macOS";
#elif defined(__linux__)
    const char *os = "Linux";
#else
    const char *os = "inny system";
#endif

#if defined(__clang__)
    const char *cc = "clang";
#elif defined(__GNUC__)
    const char *cc = "GCC";
#else
    const char *cc = "niezidentyfikowany kompilator";
#endif

    printf("Zbudowano dla %s przez %s\n", os, cc);
    printf("Standard C: %ld\n", __STDC_VERSION__);
    return 0;
}

#error warto znać samo w sobie: zatrzymuje kompilację z twoim komunikatem. Zakończenie łańcucha platform przez #else / #error "Nieobslugiwana platforma" zamienia cichy, błędny build w czytelny błąd na samej górze logu budowania.

Żeby wypisać każde makro, które predefiniuje twój kompilator:

gcc -dM -E - < /dev/null

To wyjście jest autorytatywną odpowiedzią na pytanie "co mogę sprawdzić na tej maszynie".

#if 0 do wyłączania kodu

Zakomentowanie bloku przez /* ... */ przestaje działać w chwili, gdy blok zawiera własny komentarz, bo komentarzy w C nie da się zagnieżdżać: pierwsze */ wewnątrz kończy zewnętrzny komentarz, a wszystko za nim staje się zabłąkanym kodem. #if 0 nie ma tego problemu:

#if 0
    /* Cały ten fragment jest usuwany, razem z komentarzami. */
    legacy_init();
    int n = old_calculation(42);  /* nawet ten komentarz nie przeszkadza */
    report(n);
#endif

Zmień to na #if 1, żeby przywrócić kod. Edytory nadal podświetlają go jako C, a #if 0 można zagnieździć wewnątrz innego #if.

To narzędzie do debugowania, a nie magazyn. Kod siedzący w #if 0 nigdy nie jest kompilowany, więc po cichu się psuje: zanim ktoś przestawi przełącznik, nie będzie się już kompilował. Używaj go przy zawężaniu problemu, a potem usuń blok i pozwól, żeby zapamiętał go system kontroli wersji.

Gdzie kompilacja warunkowa zawodzi

Trzy rodzaje problemów odpowiadają za większość bólu.

Kod, który nigdy nie jest kompilowany, nigdy nie jest sprawdzany. Literówka w nieaktywnej gałęzi #ifdef jest niewidoczna, dopóki ktoś nie zbuduje tej konfiguracji: może po miesiącach, może w CI na platformie, której nie masz. Jeśli projekt ma istotne gałęzie dla platform, regularnie buduj je wszystkie.

Przeplatanie #ifdef z przepływem sterowania szybko robi się nieczytelne. O czymś takim trudno myśleć:

if (ready) {
#ifdef FAST_PATH
    fast_send(buf);
} else {
#endif
    slow_send(buf);
}

Nawiasy otwarte w jednej gałęzi i zamknięte w innej są dozwolone i okropne. Wybieraj warunki, które obejmują całe funkcje, i wybieraj między nimi:

#ifdef FAST_PATH
static void send_data(const char *buf) { fast_send(buf); }
#else
static void send_data(const char *buf) { slow_send(buf); }
#endif

Zwykły if w czasie działania jest często lepszy. Jeśli obie gałęzie skompilowałyby się wszędzie, zwykłe if (debug_enabled) sprawia, że obie ścieżki są sprawdzane pod kątem typów, testowalne i przełączalne bez ponownego budowania. Zostaw preprocesor do tego, co tylko on potrafi: kodu, który naprawdę nie może skompilować się na innej platformie.

Wzorzec, który łączy to wszystko (nagłówek z wartościami domyślnymi, -D dla każdego buildu i gałęzie platform otoczone strażnikami dołączania), znajdziesz w artykule o plikach nagłówkowych; o samym #define przeczytasz w artykule o makrach.