3.1. Стадии и директивы препроцессорной обработки

Теория

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

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

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

В этом пункте нужно понять общую картину:

Что такое препроцессор

Препроцессор — это часть системы трансляции C-программы, которая обрабатывает исходный текст до того, как этот текст будет передан компилятору.

Упрощённо:

исходный файл .c
        ↓
препроцессор
        ↓
текст после препроцессорной обработки
        ↓
компилятор
        ↓
объектный код

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

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

Место препроцессора в подготовке программы

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

1. Исходный текст программы
2. Препроцессорная обработка
3. Компиляция
4. Ассемблирование
5. Компоновка
6. Исполняемый файл

На практике отдельные этапы могут быть объединены в одной команде компилятора. Например, когда программист запускает:

gcc main.c -o main

компилятор сам выполняет нужные стадии: препроцессорную обработку, компиляцию и компоновку. Но логически препроцессор всё равно работает до компилятора.

Чтобы увидеть результат только препроцессорной обработки, можно использовать ключ -E:

gcc -E main.c

Такая команда выводит текст программы после обработки препроцессором, но ещё до настоящей компиляции.

Что умеет делать препроцессор

Препроцессор выполняет несколько основных видов действий:

Примеры:

#define MAX_SIZE 100
#include <stdio.h>

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

Здесь #define задаёт замену, #include подключает заголовочный файл, а #ifdef и #endif задают условную часть текста.

Препроцессор работает с текстом

Важно понимать: препроцессор работает не с переменными времени выполнения, а с текстом программы.

#define SIZE 10

int a[SIZE];

После препроцессорной обработки компилятор увидит примерно такой текст:

int a[10];

Препроцессор не создаёт переменную SIZE. Он просто заменяет препроцессорный идентификатор SIZE на текст 10.

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

Стадии препроцессорной обработки

Препроцессорная обработка состоит из нескольких логических стадий. Конкретная реализация компилятора может объединять отдельные стадии, но результат должен быть таким, как если бы они выполнялись последовательно.

  1. Системно-зависимые обозначения переводятся в стандартные коды.
  2. Последовательности вида «обратная косая черта + конец строки» удаляются, а следующая строка присоединяется к текущей.
  3. В тексте распознаются директивы и препроцессорные лексемы, а комментарии заменяются пробельным символом.
  4. Выполняются директивы препроцессора и макроподстановки.

Эти стадии объясняют, почему некоторые конструкции препроцессора выглядят необычно: например, почему директива заканчивается концом строки и почему обратная косая черта в конце строки может продолжить директиву на следующую строку.

Стадия 1. Перевод системно-зависимых обозначений

Разные операционные системы и среды могут по-разному представлять некоторые служебные элементы текста. Например, признак конца строки в разных системах может кодироваться по-разному.

На первой стадии такие системно-зависимые обозначения приводятся к внутреннему стандартному виду, с которым дальше может работать препроцессор.

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

Стадия 2. Склеивание строк через обратную косую черту

Если в исходном тексте встречается обратная косая черта \ непосредственно перед концом строки, такая пара удаляется, а следующая строка присоединяется к текущей.

Это позволяет записывать длинные директивы препроцессора в несколько физических строк.

#define MESSAGE "Это очень длинная строка, " \
                "которую разбили на несколько частей"

Для препроцессора это будет восприниматься как одна логическая строка.

Такой приём особенно часто встречается в длинных макросах:

#define PRINT_SUM(a, b) \
    printf("sum = %d\n", (a) + (b))

Важно: после обратной косой черты в конце строки не должно быть случайных символов. Даже лишний пробел после \ может привести к проблемам в некоторых средах.

Стадия 3. Распознавание директив и комментариев

На следующей стадии препроцессор распознаёт директивы, лексемы препроцессора и комментарии.

Комментарии заменяются одним пробельным символом. Это важно: комментарий не просто «исчезает без следа», а отделяет соседние лексемы друг от друга.

int/* comment */x;

После удаления комментария эта запись становится похожей на:

int x;

А не на:

intx;

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

Стадия 4. Выполнение директив и макроподстановок

На этой стадии препроцессор выполняет директивы и заменяет макросы.

#define PI 3.14159

double area = PI * r * r;

После макроподстановки компилятор получит текст примерно такого вида:

double area = 3.14159 * r * r;

Другой пример:

#include <stdio.h>

Эта директива подключает содержимое заголовочного файла, чтобы компилятор получил объявления стандартных функций ввода-вывода, например printf и scanf.

Директивы препроцессора

Директива препроцессора — это команда для препроцессора. Каждая директива начинается с символа #.

Общий вид:

#имя_директивы лексемы_препроцессора

Примеры:

#include <stdio.h>
#define MAX_SIZE 100
#ifdef DEBUG
#endif

Директива обычно занимает одну строку. Концом директивы считается конец строки. Если директиву нужно продолжить, используют обратную косую черту \ в конце строки.

#define LONG_TEXT "Первая часть " \
                  "вторая часть"

Пробелы в директивах

В директивах допускаются пробелы перед символом #, после него и между лексемами.

#define SIZE 10
# define SIZE 10
   #define SIZE 10

Однако в учебном и рабочем коде лучше писать директивы привычно и аккуратно:

#define SIZE 10
#include <stdio.h>

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

Основные директивы препроцессора

В языке C определён набор директив препроцессора. В этой главе они будут рассматриваться подробнее, а сейчас нужно получить общее представление.

Директива Назначение
#define определение макроса или препроцессорного идентификатора
#include включение текста из файла
#undef отмена ранее выполненного определения
#if условная обработка по значению выражения
#ifdef проверка, определён ли препроцессорный идентификатор
#ifndef проверка, не определён ли препроцессорный идентификатор
#else альтернативная ветвь условной обработки
#elif сокращение для связки #else и #if
#endif окончание условной директивы
#line изменение номера следующей строки и/или имени файла для сообщений компилятора
#error формирование сообщения об ошибке трансляции
#pragma передача специальных указаний конкретной реализации компилятора
# пустая директива

Директива #define

Директива #define определяет препроцессорный идентификатор или макрос. В простейшем случае она задаёт текстовую замену.

#define SIZE 100

int a[SIZE];

После обработки препроцессором:

int a[100];

В следующих пунктах будут подробно рассмотрены обычные текстовые замены и макросы с параметрами.

Важно: после #define обычно не ставят точку с запятой.

#define SIZE 100   /* правильно */
#define SIZE 100;  /* часто ошибка по смыслу */

Во втором случае точка с запятой станет частью подстановки.

Директива #include

Директива #include включает текст из указанного файла в текущий исходный текст.

#include <stdio.h>

Эта директива нужна, например, чтобы использовать объявления стандартных функций ввода-вывода.

#include <stdio.h>

int main(void)
{
    printf("Hello\n");
    return 0;
}

На этапе препроцессорной обработки содержимое заголовочного файла фактически подставляется в программу. Подробно формы подключения файлов будут рассматриваться в пункте про #include.

Директива #undef

Директива #undef отменяет определение препроцессорного идентификатора.

#define SIZE 100

#undef SIZE

После #undef SIZE идентификатор SIZE больше не считается определённым для препроцессора.

Такая директива полезна, если нужно ограничить действие макроопределения или переопределить имя позже.

Условные директивы

Директивы #if, #ifdef, #ifndef, #else, #elif и #endif позволяют включать или исключать части текста программы до компиляции.

#define DEBUG

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

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

Условная компиляция часто используется для:

Директива #error

Директива #error заставляет препроцессор выдать ошибку с указанным сообщением.

#ifndef VERSION
#error VERSION is not defined
#endif

Такой приём можно использовать, если программа не должна компилироваться без обязательного определения.

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

Директива #pragma

Директива #pragma передаёт компилятору специальные указания, зависящие от конкретной реализации.

#pragma once

Например, #pragma once часто используется в заголовочных файлах, чтобы предотвратить повторное включение файла. Однако #pragma-директивы могут зависеть от компилятора, поэтому их нужно использовать аккуратно.

Для переносимого кода лучше знать стандартные способы решения задачи. Например, защиту заголовочного файла можно сделать через #ifndef, #define и #endif.

Пустая директива

Пустая директива состоит только из символа #.

#

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

Препроцессорные операции

Кроме директив, в препроцессоре есть специальные операции. Они будут подробно рассматриваться позже, но их нужно перечислить уже сейчас.

Операция Назначение
defined проверка, определён ли препроцессорный идентификатор
## склеивание, или конкатенация, препроцессорных лексем
# преобразование аргумента макроса в строку

Пример с defined:

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

Операции ## и # используются в макросах с параметрами и будут изучаться в пункте про макроподстановки.

Директивы и обычный код

Директивы препроцессора внешне похожи на часть программы, но они не являются обычными операторами языка C.

#define SIZE 100
int a[SIZE];

#define SIZE 100 не выполняется во время работы программы. Он обрабатывается до компиляции.

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

Неправильно:

int x = #define SIZE 100;

Правильно:

#define SIZE 100

int x = SIZE;

Комментарии и строки при препроцессорной обработке

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

#define SIZE 100

printf("SIZE");

В строковом литерале "SIZE" слово SIZE не будет заменено на 100. Строковый литерал должен остаться строкой.

А вот в обычном коде замена произойдёт:

int a[SIZE];

После препроцессорной обработки:

int a[100];

Пример полной препроцессорной обработки

Исходный файл:

#include <stdio.h>

#define SIZE 3
#define DEBUG

int main(void)
{
    int a[SIZE] = { 1, 2, 3 };
    int i;

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

    for (i = 0; i < SIZE; i++)
    {
        printf("%d\n", a[i]);
    }

    return 0;
}

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

Упрощённо можно представить результат так:

int main(void)
{
    int a[3] = { 1, 2, 3 };
    int i;

    printf("Debug mode is enabled\n");

    for (i = 0; i < 3; i++)
    {
        printf("%d\n", a[i]);
    }

    return 0;
}

На самом деле результат #include <stdio.h> будет намного больше, потому что в программу попадут объявления из стандартного заголовочного файла.

Как посмотреть результат препроцессора

При изучении препроцессора полезно смотреть, какой текст получается после обработки. Для GCC можно использовать ключ -E.

gcc -E main.c

Чтобы сохранить результат в файл:

gcc -E main.c -o main.i

Файл main.i будет содержать текст после препроцессорной обработки. Он может быть очень большим, особенно если подключены стандартные заголовочные файлы.

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

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

Ошибка 1. Точка с запятой после #define

#define SIZE 100;

Точка с запятой станет частью подстановки. Обычно нужно писать так:

#define SIZE 100

Ошибка 2. Ожидание, что #define создаёт переменную

#define COUNT 10

Это не переменная. Это текстовая подстановка до компиляции.

Ошибка 3. Неправильное продолжение директивы

#define TEXT "one" \
"two"

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

#define TEXT "one" \
             "two"

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

Ошибка 4. Забыли закрыть условную директиву

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

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

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

Ошибка 5. Попытка использовать switch/if вместо препроцессора

if (DEBUG)
{
    printf("debug\n");
}

Это обычный код времени выполнения. Он не исключает текст программы до компиляции. Если нужно именно условно включить или исключить код до компиляции, используют препроцессорные директивы:

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

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

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

#include <stdio.h>

#define MAX_SIZE 5
#define DEBUG

int main(void)
{
    int numbers[MAX_SIZE] = { 1, 2, 3, 4, 5 };
    int i;
    int sum = 0;

#ifdef DEBUG
    printf("Array size: %d\n", MAX_SIZE);
#endif

    for (i = 0; i < MAX_SIZE; i++)
    {
        sum += numbers[i];
    }

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

    return 0;
}

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

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

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

  1. Что такое препроцессор?
  2. На каком этапе подготовки программы работает препроцессор?
  3. Что поступает на вход препроцессора?
  4. Что получается после препроцессорной обработки?
  5. Какие основные действия может выполнять препроцессор?
  6. С какого символа начинается директива препроцессора?
  7. Чем обычно заканчивается директива препроцессора?
  8. Для чего используется обратная косая черта в конце строки?
  9. Что делает директива #define?
  10. Что делает директива #include?
  11. Для чего нужна директива #undef?
  12. Какие директивы используются для условной обработки текста?
  13. Чем препроцессорная условная обработка отличается от обычного if?
  14. Как посмотреть результат препроцессорной обработки через GCC?