3.4. Условная компиляция

Теория

Зачем нужен этот пункт

Иногда нужно, чтобы часть программы попадала в компиляцию только при определённых условиях. Например, во время отладки полезно выводить дополнительную информацию, а в итоговой версии программы этот вывод лучше полностью убрать.

Для таких задач используется условная компиляция. Несмотря на название, она выполняется не самим компилятором, а препроцессором: он решает, какие части текста программы оставить, а какие исключить ещё до компиляции.

В этом пункте рассматриваются:

Что такое условная компиляция

Условная компиляция — это возможность включать или исключать фрагменты исходного текста программы на этапе препроцессорной обработки.

#define DEBUG

#ifdef DEBUG
    printf("Debug mode\n");
#endif

Если идентификатор DEBUG определён, строка с printf останется в тексте, который получит компилятор. Если DEBUG не определён, этот фрагмент будет исключён до компиляции.

Важно: исключённый текст не становится частью программы. Он не будет проверяться компилятором как обычный исполняемый код и не попадёт в итоговый исполняемый файл.

Условная компиляция и обычный if

Обычный оператор if работает во время выполнения программы. Препроцессорная директива #if работает до компиляции.

Обычный if

if (debugMode)
{
    printf("Debug information\n");
}

Этот код компилируется целиком. Решение о выполнении принимается во время работы программы.

Препроцессорный #ifdef

#ifdef DEBUG
    printf("Debug information\n");
#endif

Здесь решение принимается до компиляции. Если DEBUG не определён, строка с printf вообще не попадёт к компилятору.

Конструкция Когда проверяется Что выбирает
if во время выполнения программы какой оператор выполнить
#if, #ifdef, #ifndef до компиляции какой текст передать компилятору

Основные директивы условной компиляции

Для условной обработки текста используются следующие директивы:

Директива Назначение
#if проверяет целочисленное константное выражение
#ifdef проверяет, определён ли идентификатор
#ifndef проверяет, не определён ли идентификатор
#else задаёт альтернативную ветвь
#elif задаёт дополнительное условие, если предыдущие условия ложны
#endif завершает условный блок

Каждая условная конструкция обязательно должна завершаться директивой #endif.

Общая схема условной компиляции

Самая простая схема:

#if условие
    текст_1
#endif

Если условие истинно, текст_1 остаётся в программе. Если условие ложно, текст_1 исключается.

Схема с альтернативной ветвью:

#if условие
    текст_1
#else
    текст_2
#endif

Если условие истинно, в программу попадёт текст_1. Если условие ложно, в программу попадёт текст_2.

Препроцессор всегда выбирает только нужный участок текста.

Директива #if

Директива #if проверяет целочисленное константное выражение.

#if целочисленное_константное_выражение
    текст
#endif

Если выражение не равно нулю, оно считается истинным. Если выражение равно нулю, оно считается ложным.

#define VERSION 2

#if VERSION >= 2
    printf("New version\n");
#endif

После подстановки VERSION условие станет таким:

#if 2 >= 2

Условие истинно, поэтому строка с printf останется в программе.

Что можно использовать в #if

В выражении после #if можно использовать:

#define LEVEL 3
#define DEBUG 1

#if LEVEL > 1 && DEBUG
    printf("Detailed debug information\n");
#endif

Здесь условие истинно, если LEVEL больше 1 и DEBUG не равен нулю.

Что нельзя использовать в #if

В #if нельзя использовать обычные переменные времени выполнения, вещественные значения и вызовы обычных функций.

Ошибочно:

int x = 10;

#if x > 0
    printf("x positive\n");
#endif

Переменная x появляется только на этапе компиляции и выполнения программы. Препроцессор не знает её значения.

Ошибочно:

#if 3.14 > 0
    printf("pi\n");
#endif

Выражение для #if должно быть целочисленным константным выражением.

Ошибочно:

#if strlen("abc") > 0
    printf("text\n");
#endif

Препроцессор не вызывает обычные функции языка C.

Неопределённые идентификаторы в #if

Если в выражении #if встречается идентификатор, который не определён как препроцессорный макрос, он обычно считается равным нулю.

#if DEBUG
    printf("Debug\n");
#endif

Если DEBUG не был определён через #define или параметр сборки, условие будет рассматриваться как:

#if 0

Поэтому отладочный вывод будет исключён.

Но для проверки самого факта определения имени часто лучше использовать #ifdef или defined.

Директива #ifdef

Директива #ifdef проверяет, был ли идентификатор определён препроцессором.

#ifdef идентификатор
    текст
#endif

Пример:

#define DEBUG

#ifdef DEBUG
    printf("Debug mode is enabled\n");
#endif

Здесь DEBUG определён, поэтому текст внутри блока будет передан компилятору.

Обрати внимание: для #ifdef не важно, чему равен макрос. Важно только то, что он определён.

#define DEBUG 0

#ifdef DEBUG
    printf("Этот текст всё равно попадёт в программу\n");
#endif

Хотя DEBUG равен 0, он всё равно определён. Поэтому #ifdef DEBUG истинно.

Директива #ifndef

Директива #ifndef проверяет обратное условие: не определён ли идентификатор.

#ifndef идентификатор
    текст
#endif

Пример:

#ifndef MAX_SIZE
#define MAX_SIZE 100
#endif

Этот фрагмент означает: если MAX_SIZE ещё не определён, определить его как 100.

#ifndef часто используется в защите заголовочных файлов от повторного включения.

Защита заголовочного файла через #ifndef

В собственных заголовочных файлах обычно используют такую конструкцию:

#ifndef ARRAY_UTILS_H
#define ARRAY_UTILS_H

int arraySum(int a[], int n);
int arrayMax(int a[], int n);

#endif

При первом включении файла идентификатор ARRAY_UTILS_H ещё не определён, поэтому содержимое заголовка обрабатывается. Затем выполняется #define ARRAY_UTILS_H.

При повторном включении этого же заголовка идентификатор уже определён, поэтому текст между #ifndef и #endif будет пропущен.

Такая конструкция называется защитой от повторного включения, или include guard.

Директива #else

Директива #else задаёт альтернативную часть условного блока.

#define DEBUG

#ifdef DEBUG
    printf("Debug build\n");
#else
    printf("Release build\n");
#endif

Если DEBUG определён, в программу попадёт первая строка. Если DEBUG не определён, в программу попадёт строка после #else.

Внутри одного условного блока может быть только одна директива #else.

Директива #elif

Директива #elif означает «иначе если». Она используется, когда нужно выбрать один вариант из нескольких.

#define PLATFORM 2

#if PLATFORM == 1
    printf("Windows\n");
#elif PLATFORM == 2
    printf("Linux\n");
#elif PLATFORM == 3
    printf("macOS\n");
#else
    printf("Unknown platform\n");
#endif

Препроцессор проверяет условия сверху вниз. Как только найдено истинное условие, соответствующий текст выбирается, а остальные ветви пропускаются.

Если ни одно условие не истинно, выбирается ветвь #else, если она есть.

Директива #endif

Директива #endif завершает условный блок.

#ifdef DEBUG
    printf("Debug\n");
#endif

Если забыть #endif, препроцессор не сможет правильно определить, где заканчивается условная область.

Для читаемости после #endif часто добавляют комментарий:

#ifdef DEBUG
    printf("Debug\n");
#endif /* DEBUG */

Это особенно полезно, если условный блок длинный.

Операция defined

Операция defined используется внутри условий #if и #elif. Она проверяет, определён ли препроцессорный идентификатор.

Есть две формы записи:

defined ИДЕНТИФИКАТОР
defined(ИДЕНТИФИКАТОР)

Если идентификатор определён, результат равен 1. Если не определён — 0.

#if defined(DEBUG)
    printf("Debug mode\n");
#endif

Эта запись эквивалентна:

#ifdef DEBUG
    printf("Debug mode\n");
#endif

Зачем нужен defined

Для простой проверки одного идентификатора можно использовать #ifdef. Но defined удобен, когда условие сложное.

#if defined(DEBUG) && !defined(RELEASE)
    printf("Debug information\n");
#endif

Этот фрагмент означает: включить текст только тогда, когда DEBUG определён, а RELEASE не определён.

Без defined такую проверку пришлось бы записывать вложенными директивами:

#ifdef DEBUG
#ifndef RELEASE
    printf("Debug information\n");
#endif
#endif

Оба варианта работают, но с defined сложные условия часто читаются короче.

#ifdef и #if defined

Эти две формы часто означают одно и то же.

Запись Эквивалент
#ifdef DEBUG #if defined(DEBUG)
#ifndef DEBUG #if !defined(DEBUG)

Для одной простой проверки обычно удобнее #ifdef или #ifndef. Для сложных логических условий удобнее #if defined(...).

Режим отладки через DEBUG

Один из самых частых вариантов условной компиляции — включение отладочного вывода.

#include <stdio.h>

#define DEBUG

int main(void)
{
    int x = 10;

#ifdef DEBUG
    printf("DEBUG: x = %d\n", x);
#endif

    printf("Program result: %d\n", x * 2);

    return 0;
}

Если DEBUG определён, программа выведет дополнительную отладочную строку. Если убрать строку #define DEBUG, отладочный вывод не попадёт в программу.

Определение макроса при сборке

Макрос можно определить не только внутри файла через #define, но и при запуске компилятора.

gcc main.c -DDEBUG -o program

Ключ -DDEBUG сообщает препроцессору, что идентификатор DEBUG считается определённым.

Можно также передать значение:

gcc main.c -DVERSION=2 -o program

Тогда в программе можно использовать:

#if VERSION >= 2
    printf("Version 2 or newer\n");
#endif

Такой подход удобен, когда один и тот же исходный код нужно собирать в разных режимах.

Отключение кода через #if 0

Иногда нужно временно исключить большой фрагмент кода из компиляции. Для этого часто используют конструкцию #if 0.

#if 0
    printf("Этот код временно отключён\n");
    oldFunction();
#endif

Так как условие 0 ложно, текст между #if 0 и #endif будет исключён.

Такой способ удобнее, чем помещать большой фрагмент в комментарий, потому что внутри отключённого блока могут быть обычные комментарии.

Но злоупотреблять #if 0 не стоит. Старый ненужный код лучше удалять, если он больше не нужен.

Выбор платформы

Условная компиляция часто используется для различий между платформами. Например, в разных системах могут использоваться разные заголовочные файлы или разные функции.

#if defined(_WIN32)
    printf("Windows\n");
#elif defined(__linux__)
    printf("Linux\n");
#else
    printf("Unknown system\n");
#endif

Здесь выбирается один из фрагментов в зависимости от того, какие макросы определены компилятором или системой сборки.

Такие системные макросы зависят от компилятора и платформы, поэтому при переносимом программировании их нужно использовать аккуратно.

Выбор разных реализаций функции

Условная компиляция может использоваться для выбора разных вариантов реализации.

#include <stdio.h>

#define FAST_MODE

int calculate(int x)
{
#ifdef FAST_MODE
    return x * 2;
#else
    int result = 0;
    int i;

    for (i = 0; i < 2; i++)
    {
        result += x;
    }

    return result;
#endif
}

int main(void)
{
    printf("%d\n", calculate(10));
    return 0;
}

Если FAST_MODE определён, используется короткая реализация. Если не определён — используется альтернативный вариант.

Важно следить, чтобы в любом выбранном варианте код оставался корректным.

Условная компиляция внутри функции

Директивы условной компиляции можно размещать внутри функций, потому что они работают с текстом программы.

int main(void)
{
    int value = 10;

#ifdef DEBUG
    printf("value = %d\n", value);
#endif

    return 0;
}

После препроцессорной обработки отладочная строка либо останется внутри функции, либо будет удалена.

Но не стоит делать код слишком «рваным», когда директивы разбивают обычные конструкции языка на трудно читаемые части.

Условная компиляция и синтаксическая корректность

Компилятор видит только тот текст, который остался после работы препроцессора. Поэтому каждая возможная выбранная ветвь должна образовывать корректный C-код.

#ifdef DEBUG
    printf("Debug\n");
#else
    printf("Release\n");
#endif

Если DEBUG определён, компилятор увидит только первую строку. Если не определён — только вторую.

Ошибка может быть скрыта в ветви, которая сейчас не компилируется. Поэтому при разработке полезно иногда проверять разные режимы сборки.

Неправильное разрывание конструкций

Условные директивы можно вставлять почти в любое место текста, но это не значит, что так нужно делать.

Плохой стиль:

printf(
#ifdef DEBUG
    "Debug\n"
#else
    "Release\n"
#endif
);

Такой код может работать, но читать его неудобно. Лучше выбирать целые операторы или целые фрагменты кода:

#ifdef DEBUG
    printf("Debug\n");
#else
    printf("Release\n");
#endif

Условная компиляция должна помогать структуре программы, а не делать её менее понятной.

Пример: программа с двумя режимами

В этом примере одна и та же программа может собираться в обычном и отладочном режиме.

#include <stdio.h>

int main(void)
{
    int a = 10;
    int b = 5;
    int result;

#ifdef DEBUG
    printf("DEBUG: a = %d\n", a);
    printf("DEBUG: b = %d\n", b);
#endif

    result = a + b;

#ifdef DEBUG
    printf("DEBUG: result calculated\n");
#endif

    printf("result = %d\n", result);

    return 0;
}

Обычная сборка:

gcc main.c -o program

Сборка с отладочным режимом:

gcc main.c -DDEBUG -o program

При сборке с -DDEBUG в программу попадут дополнительные строки вывода.

Пример: выбор размера массива

Через условную компиляцию можно выбрать настройки программы.

#include <stdio.h>

#define LARGE_DATA

#ifdef LARGE_DATA
#define MAX_SIZE 1000
#else
#define MAX_SIZE 100
#endif

int main(void)
{
    int array[MAX_SIZE];

    printf("MAX_SIZE = %d\n", MAX_SIZE);

    return 0;
}

Если LARGE_DATA определён, MAX_SIZE станет равен 1000. Если не определён — 100.

Так можно хранить несколько вариантов настроек в одном исходном тексте.

Вложенные условные директивы

Условные директивы можно вкладывать друг в друга.

#ifdef DEBUG
    #ifdef VERBOSE
        printf("Detailed debug information\n");
    #else
        printf("Short debug information\n");
    #endif
#endif

Здесь подробная отладочная информация выводится только если определены оба режима: DEBUG и VERBOSE.

Вложенность нужно использовать аккуратно. Если таких уровней становится слишком много, код быстро становится трудным для чтения.

Как упростить вложенные условия

Иногда вложенные #ifdef можно заменить одним условием с defined.

Вложенный вариант:

#ifdef DEBUG
#ifndef RELEASE
    printf("Debug only\n");
#endif
#endif

Более компактный вариант:

#if defined(DEBUG) && !defined(RELEASE)
    printf("Debug only\n");
#endif

Оба варианта означают одно и то же: включить текст только тогда, когда DEBUG определён, а RELEASE не определён.

Условная компиляция и комментарии

Иногда условную компиляцию используют вместо большого комментария.

#if 0
/*
    Здесь может быть старый код,
    внутри которого уже есть комментарии.
*/
oldFunction();
#endif

Это удобно, потому что обычные комментарии в C нельзя вкладывать друг в друга:

/* внешний комментарий
    /* внутренний комментарий */
*/

Такая запись ошибочна. А блок #if 0 ... #endif позволяет временно отключить большой участок текста без этой проблемы.

Типичные ошибки

Ошибка 1. Забыли #endif

#ifdef DEBUG
    printf("Debug\n");

Нужно закрыть условный блок:

#ifdef DEBUG
    printf("Debug\n");
#endif

Ошибка 2. Ожидание, что #ifdef проверяет значение

#define DEBUG 0

#ifdef DEBUG
    printf("Debug\n");
#endif

Этот текст будет включён, потому что DEBUG определён. Если нужно проверить именно значение, используй #if:

#define DEBUG 0

#if DEBUG
    printf("Debug\n");
#endif

Ошибка 3. Использование обычной переменной в #if

int mode = 1;

#if mode == 1
    printf("Mode 1\n");
#endif

Препроцессор не знает значение переменной mode. Для проверки во время выполнения нужен обычный if.

Ошибка 4. Использование вещественного условия

#if 3.14 > 0
    printf("pi\n");
#endif

В #if используются целочисленные константные выражения.

Ошибка 5. Слишком сложная вложенность

#ifdef A
#ifdef B
#ifdef C
    printf("Too deep\n");
#endif
#endif
#endif

Такой код быстро становится трудным для чтения. Часто лучше записать условие через defined:

#if defined(A) && defined(B) && defined(C)
    printf("Clear condition\n");
#endif

Ошибка 6. Скрытая ошибка в неактивной ветви

#ifdef DEBUG
    printf("Debug\n");
#else
    syntax error here
#endif

Если DEBUG определён, ветвь #else может не проверяться компилятором. Ошибка обнаружится только при другой сборке.

Практические рекомендации

Мини-разбор программы

#include <stdio.h>

#define VERSION 2

int main(void)
{
    int value = 10;

#if VERSION >= 2
    printf("Version 2 mode\n");
#else
    printf("Old version mode\n");
#endif

#ifdef DEBUG
    printf("DEBUG: value = %d\n", value);
#endif

#if defined(DEBUG) && !defined(RELEASE)
    printf("Debug build without release flag\n");
#endif

    printf("value = %d\n", value);

    return 0;
}

Разберём программу:

Что нужно запомнить

Самопроверка перед переходом дальше

  1. Что такое условная компиляция?
  2. Почему условная компиляция выполняется до обычной компиляции?
  3. Чем #if отличается от обычного оператора if?
  4. Что проверяет директива #ifdef?
  5. Что проверяет директива #ifndef?
  6. Почему #ifdef DEBUG истинно при #define DEBUG 0?
  7. Когда лучше использовать #if DEBUG, а не #ifdef DEBUG?
  8. Для чего нужна директива #else?
  9. Для чего нужна директива #elif?
  10. Почему каждый условный блок нужно закрывать через #endif?
  11. Что делает операция defined?
  12. Чем #ifdef X отличается от #if defined(X)?
  13. Как собрать программу с определённым макросом через gcc?
  14. Зачем используется конструкция #if 0 ... #endif?
  15. Как условная компиляция применяется в защите заголовочных файлов?