3.4. Условная компиляция
Теория
Зачем нужен этот пункт
Иногда нужно, чтобы часть программы попадала в компиляцию только при определённых условиях. Например, во время отладки полезно выводить дополнительную информацию, а в итоговой версии программы этот вывод лучше полностью убрать.
Для таких задач используется условная компиляция. Несмотря на название, она выполняется не самим компилятором, а препроцессором: он решает, какие части текста программы оставить, а какие исключить ещё до компиляции.
В этом пункте рассматриваются:
- общая идея условной компиляции;
- директивы
#if,#ifdef,#ifndef; - директивы
#else,#elif,#endif; - операция
defined; - отличие препроцессорных условий от обычного
if; - режимы сборки программы через макросы;
- защита заголовочных файлов от повторного включения;
- типичные ошибки при условной компиляции.
Что такое условная компиляция
Условная компиляция — это возможность включать или исключать фрагменты исходного текста программы на этапе препроцессорной обработки.
#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; - операцию
defined.
#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 может не
проверяться компилятором. Ошибка обнаружится только при другой сборке.
Практические рекомендации
- Используй условную компиляцию для режимов сборки, отладки и платформенных различий.
- Для проверки факта определения используй
#ifdefили#ifndef. - Для проверки значения макроса используй
#if. - Для сложных условий используй
defined. - Всегда закрывай условные блоки директивой
#endif. - После длинных
#endifдобавляй поясняющий комментарий. - Не путай препроцессорные условия с обычным оператором
if. - Проверяй разные режимы сборки, чтобы ошибки не прятались в неактивных ветвях.
- Не делай слишком глубокую вложенность условных директив.
- Старайся включать и исключать целые логические фрагменты кода, а не отдельные куски выражений.
Мини-разбор программы
#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;
}
Разберём программу:
VERSIONиспользуется в директиве#ifдля выбора версии кода;#elseзадаёт альтернативный текст для старой версии;#ifdef DEBUGвключает отладочный вывод только при наличии макросаDEBUG;defined(DEBUG)проверяет, определён ли макросDEBUG;!defined(RELEASE)проверяет, что макросRELEASEне определён;- компилятор получит только тот текст, который останется после работы препроцессора.
Что нужно запомнить
- Условная компиляция выполняется препроцессором до компиляции.
- Она выбирает, какие части текста программы передать компилятору.
#ifпроверяет целочисленное константное выражение.#ifdefпроверяет, определён ли идентификатор.#ifndefпроверяет, не определён ли идентификатор.#elseзадаёт альтернативную ветвь.#elifзадаёт дополнительное условие.#endifзавершает условный блок.#ifdef DEBUGистинно даже при#define DEBUG 0.- Операция
definedиспользуется внутри#ifи#elif. #if defined(X)эквивалентно#ifdef X.#if !defined(X)эквивалентно#ifndef X.- Обычные переменные нельзя использовать в препроцессорных условиях.
- Макросы можно определять при сборке, например через
gcc -DDEBUG. - Защита заголовочных файлов обычно строится через
#ifndef,#define,#endif.
Самопроверка перед переходом дальше
- Что такое условная компиляция?
- Почему условная компиляция выполняется до обычной компиляции?
- Чем
#ifотличается от обычного оператораif? - Что проверяет директива
#ifdef? - Что проверяет директива
#ifndef? - Почему
#ifdef DEBUGистинно при#define DEBUG 0? - Когда лучше использовать
#if DEBUG, а не#ifdef DEBUG? - Для чего нужна директива
#else? - Для чего нужна директива
#elif? - Почему каждый условный блок нужно закрывать через
#endif? - Что делает операция
defined? - Чем
#ifdef Xотличается от#if defined(X)? - Как собрать программу с определённым макросом через
gcc? - Зачем используется конструкция
#if 0 ... #endif? - Как условная компиляция применяется в защите заголовочных файлов?