3.1. Стадии и директивы препроцессорной обработки
Теория
Зачем нужен этот пункт
До этого программа рассматривалась в основном как текст на языке C, который компилятор переводит в машинный код. Но перед собственно компиляцией исходный файл проходит ещё один важный этап — препроцессорную обработку.
Препроцессор работает с текстом программы до компилятора. Он может подключать файлы, выполнять текстовые замены, исключать или включать части кода по условиям, формировать макроподстановки и обрабатывать специальные директивы.
В этом пункте нужно понять общую картину:
- что такое препроцессор;
- какое место он занимает при подготовке программы;
- что подаётся на вход препроцессора и что получается на выходе;
- какие стадии выполняются при препроцессорной обработке;
- как записываются директивы препроцессора;
- какие основные директивы есть в языке 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. Склеивание строк через обратную косую черту
Если в исходном тексте встречается обратная косая черта
\ непосредственно перед концом строки, такая пара удаляется,
а следующая строка присоединяется к текущей.
Это позволяет записывать длинные директивы препроцессора в несколько физических строк.
#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;
}
После препроцессорной обработки компилятор получит текст, в котором:
- содержимое
stdio.hбудет подключено; SIZEбудет заменено на3;- условный блок
#ifdef DEBUG ... #endifостанется в коде; - сами директивы препроцессора исчезнут из итогового текста.
Упрощённо можно представить результат так:
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
Практические рекомендации
- Помни, что препроцессор работает до компилятора.
- Директивы препроцессора начинаются с символа
#. - Обычно каждая директива занимает отдельную строку.
- Не ставь точку с запятой после
#define, если она не должна быть частью подстановки. - Используй
#includeдля подключения заголовочных файлов. - Используй
#defineаккуратно: это текстовая подстановка, а не переменная. - Для условного включения кода используй
#ifdef,#ifndef,#if. - Всегда закрывай условные директивы с помощью
#endif. - Для просмотра результата препроцессора используй режим только препроцессорной обработки, например
gcc -E. - Не злоупотребляй макросами там, где можно использовать обычные функции и переменные.
Мини-разбор программы
#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;
}
Разберём программу:
#include <stdio.h>подключает объявления стандартного ввода-вывода;#define MAX_SIZE 5задаёт текстовую замену размера массива;#define DEBUGопределяет препроцессорный идентификатор для режима отладки;#ifdef DEBUGвключает отладочный вывод только еслиDEBUGопределён;#endifзавершает условный препроцессорный блок;- после препроцессорной обработки компилятор увидит уже подготовленный текст без этих директив.
Что нужно запомнить
- Препроцессор обрабатывает исходный текст программы до компиляции.
- На вход препроцессора поступает текст с директивами, на выходе получается текст без обработанных директив.
- Препроцессор может выполнять текстовые замены, подключать файлы и условно исключать части кода.
- Директивы препроцессора начинаются с символа
#. - Окончанием директивы обычно является конец строки.
- Обратная косая черта в конце строки продолжает директиву на следующей строке.
- Комментарии при обработке заменяются пробельным символом.
#defineзадаёт макрос или препроцессорный идентификатор.#includeвключает текст из файла.#undefотменяет определение.#if,#ifdef,#ifndef,#else,#elif,#endifиспользуются для условной обработки.#errorпозволяет остановить трансляцию с сообщением об ошибке.#pragmaзависит от конкретной реализации компилятора.- Препроцессорные операции:
defined,##и#.
Самопроверка перед переходом дальше
- Что такое препроцессор?
- На каком этапе подготовки программы работает препроцессор?
- Что поступает на вход препроцессора?
- Что получается после препроцессорной обработки?
- Какие основные действия может выполнять препроцессор?
- С какого символа начинается директива препроцессора?
- Чем обычно заканчивается директива препроцессора?
- Для чего используется обратная косая черта в конце строки?
- Что делает директива
#define? - Что делает директива
#include? - Для чего нужна директива
#undef? - Какие директивы используются для условной обработки текста?
- Чем препроцессорная условная обработка отличается от обычного
if? - Как посмотреть результат препроцессорной обработки через GCC?