3.2. Замены в тексте
Теория
Зачем нужен этот пункт
Препроцессор может выполнять текстовые замены до того, как программа
будет передана компилятору. Для этого используется директива
#define.
С помощью #define можно дать имя числу, строке, выражению,
типу или даже фрагменту кода. После этого препроцессор будет заменять
выбранный идентификатор заранее заданной последовательностью символов.
В этом пункте рассматриваются:
- общая форма директивы
#define; - простые текстовые замены;
- область действия препроцессорного определения;
- цепочки подстановок;
- места, где замены не выполняются;
- перенос длинной строки замещения;
- переопределение идентификаторов;
- отмена определения через
#undef; - типичные ошибки при использовании
#define.
Общая форма #define
Директива #define задаёт замену одного идентификатора
на некоторую строку замещения.
#define идентификатор строка_замещения
Например:
#define MAX_SIZE 100
После такой директивы препроцессор будет заменять отдельную лексему
MAX_SIZE на текст 100.
int array[MAX_SIZE];
После препроцессорной обработки компилятор увидит примерно такой текст:
int array[100];
Важно: MAX_SIZE — это не переменная. Это имя для текстовой
подстановки, которая выполняется до компиляции.
Простая замена на число
Самый частый учебный вариант — использование #define
для именованных числовых констант.
#define DAYS_IN_WEEK 7
#define MAX_STUDENTS 30
#define PI 3.14159
Такие имена делают программу понятнее.
Плохо читается:
area = 3.14159 * radius * radius;
Лучше:
#define PI 3.14159
area = PI * radius * radius;
Теперь по коду понятно, что PI — это число π, а не случайное
число, взятое без объяснения.
После #define обычно не ставят точку с запятой
Директива #define не является обычным оператором языка C.
Поэтому после неё обычно не ставят точку с запятой.
Правильно:
#define SIZE 100
Опасно:
#define SIZE 100;
Во втором случае точка с запятой станет частью строки замещения. Тогда код:
int a[SIZE];
после подстановки может превратиться в:
int a[100;];
Это приведёт к ошибке компиляции.
Область действия #define
Директива #define начинает действовать с того места,
где она записана. Обычно её действие продолжается до конца файла
или до отмены через #undef.
int a = SIZE; /* здесь SIZE ещё не определён */
#define SIZE 100
int b = SIZE; /* здесь SIZE заменится на 100 */
Поэтому препроцессорные определения обычно размещают в начале файла:
после #include и до функций.
#include <stdio.h>
#define MAX_SIZE 100
#define PI 3.14159
int main(void)
{
return 0;
}
Строка замещения
Строкой замещения называется текст, который будет подставляться вместо препроцессорного идентификатора.
#define NAME replacement_text
В строку замещения может входить:
- число;
- строковый литерал;
- символьная константа;
- выражение;
- тип данных;
- фрагмент оператора;
- вызов функции.
Примеры:
#define LIMIT 100
#define MESSAGE "Hello"
#define LETTER 'A'
#define RANGE ((INT_MAX) - (INT_MIN) + 1)
#define REAL long double
#define PRINT_HELLO printf("Hello\n")
Но чем сложнее строка замещения, тем осторожнее нужно использовать
#define. Препроцессор не проверяет типы так, как это делает
компилятор.
Пробелы в строке замещения
Начальные и конечные пробелы строки замещения не считаются частью подставляемого текста.
#define SIZE 100
Здесь между SIZE и 100 можно поставить несколько
пробелов. Смысл будет тем же: SIZE заменяется на 100.
Но пробелы внутри самой строки замещения сохраняют смысл, если они разделяют лексемы.
#define REAL long double
Здесь строка замещения состоит из двух слов: long и
double. Пробел между ними нужен.
Замены выполняются только для отдельных лексем
Препроцессор заменяет только отдельные вхождения идентификатора. Он не заменяет часть другого идентификатора.
#define RANGE 100
int x = RANGE;
int RANGE_T = 5;
После препроцессорной обработки:
int x = 100;
int RANGE_T = 5;
Идентификатор RANGE_T не изменился, потому что
RANGE внутри него не является отдельной лексемой.
Это важное правило: препроцессор не ищет подстроки внутри имён, а работает с препроцессорными лексемами.
Замены не выполняются внутри строк
Если препроцессорный идентификатор встречается внутри строкового литерала, он не заменяется.
#define SIZE 100
printf("SIZE");
printf("%d", SIZE);
После препроцессорной обработки получится примерно:
printf("SIZE");
printf("%d", 100);
В строке "SIZE" текст остался без изменений.
А отдельная лексема SIZE во втором вызове была заменена
на 100.
Замены не выполняются внутри символьных констант
Символьные константы тоже не подвергаются таким заменам.
#define n 24
char c = 'n';
int k = n;
После обработки:
char c = 'n';
int k = 24;
Символ 'n' остался символом n. Заменилось только
отдельное имя n в выражении int k = n;.
Замены не выполняются внутри комментариев
Комментарии предназначены для человека. Препроцессорные замены внутри комментариев не выполняются.
#define SIZE 100
/* SIZE - максимальный размер массива */
int a[SIZE];
После обработки:
/* SIZE - максимальный размер массива */
int a[100];
Комментарий остался пояснением. В нём слово SIZE не заменилось.
Пример с заменой одной буквы
Рассмотрим пример, который хорошо показывает ограничения текстовой замены.
#define n 24
char c = '\n';
/* \n - управляющая последовательность */
printf("\n Строковая константа\n");
c = 'n' > '\n' ? 'n' : '\n';
int k = n;
Здесь замена n на 24 выполнится только в последней
строке:
int k = 24;
Остальные вхождения буквы n находятся внутри строк,
символьных констант, управляющих последовательностей или комментариев.
Поэтому они не заменяются.
Цепочка подстановок
Если строка замещения сама содержит препроцессорный идентификатор, который был определён раньше, препроцессор может выполнить цепочку последовательных подстановок.
#define A 10
#define B A + 5
int x = B;
Упрощённо:
B заменяется на A + 5
A заменяется на 10
int x = 10 + 5;
Это называется цепочкой подстановок.
Пример цепочки с limits.h
Стандартный заголовочный файл limits.h содержит константы,
связанные с предельными значениями целочисленных типов.
#include <limits.h>
#define RANGE ((INT_MAX) - (INT_MIN) + 1)
int rangePart = RANGE / 8;
Сначала препроцессор обрабатывает #include <limits.h>.
Из заголовочного файла становятся известны, например, имена
INT_MAX и INT_MIN.
Затем RANGE раскрывается как выражение:
((INT_MAX) - (INT_MIN) + 1)
А INT_MAX и INT_MIN тоже могут быть раскрыты
в конкретные значения, зависящие от реализации.
Итоговая идея такая:
int rangePart = ((INT_MAX) - (INT_MIN) + 1) / 8;
При этом в реальном препроцессорном выводе значения и дополнительные определения зависят от компилятора и платформы.
Зачем в выражениях macro ставить скобки
Если строка замещения является выражением, её лучше заключать в скобки. Это защищает код от ошибок с приоритетами операций.
Плохой вариант:
#define RANGE INT_MAX - INT_MIN + 1
int x = RANGE / 8;
После подстановки получится:
int x = INT_MAX - INT_MIN + 1 / 8;
Деление выполнится только для 1 / 8, а не для всего диапазона.
Лучше:
#define RANGE ((INT_MAX) - (INT_MIN) + 1)
int x = RANGE / 8;
После подстановки:
int x = ((INT_MAX) - (INT_MIN) + 1) / 8;
Теперь порядок вычислений соответствует ожиданию.
Замена на строку
С помощью #define можно задать имя для строкового литерала.
#define MESSAGE "Программа завершена"
printf("%s\n", MESSAGE);
После препроцессорной обработки:
printf("%s\n", "Программа завершена");
Это может быть удобно, если один и тот же текст используется в нескольких местах программы.
Перенос длинной строки замещения
Директива препроцессора обычно заканчивается концом строки.
Если строка замещения слишком длинная, её можно продолжить на следующей
физической строке с помощью обратной косой черты \
в конце строки.
#define MESSAGE "Game Over! - " \
"Игра закончена!"
Теперь можно написать:
printf(MESSAGE);
Препроцессор воспринимает такое определение как одну логическую строку.
Важно: после символа \ в конце строки не должно быть
лишних символов и пробелов. Иначе продолжение строки может не сработать.
Замена на тип данных
С помощью #define можно ввести короткое имя для типа.
#define REAL long double
REAL x;
REAL array[6];
После подстановки компилятор увидит:
long double x;
long double array[6];
Такой приём встречается в старом C-коде, но в современном стиле
для имён типов часто удобнее использовать typedef.
typedef long double Real;
Разница в том, что #define выполняет простую текстовую замену,
а typedef является конструкцией самого языка C и лучше
проверяется компилятором.
Замена на фрагмент оператора
Иногда через #define задают сокращение для часто используемого
фрагмента кода.
#define PRINT_N printf("N = %d\n", N)
Тогда:
int N = 4;
PRINT_N;
после подстановки станет примерно:
int N = 4;
printf("N = %d\n", N);
Такой приём нужно использовать осторожно. Он может сделать код короче, но иногда ухудшает читаемость, потому что за коротким именем скрывается целый оператор.
Для обычных повторяющихся действий чаще лучше написать функцию.
Почему макрос-оператор может быть опасен
Рассмотрим такой вариант:
#define PRINT_N printf("N = %d\n", N);
Здесь точка с запятой включена в строку замещения. Это может привести к неожиданным ошибкам в условных операторах.
if (N > 0)
PRINT_N;
else
printf("N is not positive\n");
После подстановки лишняя точка с запятой может нарушить структуру
if ... else.
Поэтому для простого курса лучше придерживаться правила:
Через #define задаём в основном константы и простые выражения,
а повторяющиеся действия оформляем функциями.
Переопределение идентификатора
Один и тот же препроцессорный идентификатор не стоит без необходимости определять несколько раз.
#define M 16
#define M 'C'
#define M "C"
С точки зрения идеи текстовой замены это означает попытку сменить
строку замещения для имени M. Но такой код плохо читается
и может вызывать предупреждения компилятора.
Правильнее явно отменить старое определение, а затем задать новое:
#define M 16
#undef M
#define M 'C'
#undef M
#define M "C"
Так видно, что изменение определения сделано осознанно.
Отмена определения через #undef
Директива #undef отменяет определение препроцессорного
идентификатора.
#define SIZE 100
#undef SIZE
После #undef SIZE имя SIZE больше не считается
определённым для препроцессора.
Например:
#define VALUE 10
int a = VALUE;
#undef VALUE
int b = VALUE; /* ошибка, если VALUE нигде больше не определён */
В первой строке VALUE заменится на 10.
После #undef такой замены уже не будет.
Зачем нужен #undef
Директива #undef полезна в больших программах, где разные
части кода могут использовать одинаковые короткие имена.
Например, временно можно заменить имя A на другое имя,
а потом отменить замену:
int A = 10;
int X = 0;
int B;
#define A X
A = 5; /* после подстановки это X = 5; */
#undef A
B = A; /* здесь снова используется обычная переменная A */
После обработки логика будет такой:
int A = 10;
int X = 0;
int B;
X = 5;
B = A;
В итоге B получит значение обычной переменной A,
то есть 10, а не 5.
На практике такие приёмы нужны редко, но они показывают, что препроцессор действительно работает с текстом программы.
#define и const: что выбрать
Для именованных числовых значений можно использовать и #define,
и const.
#define MAX_SIZE 100
const int maxSize = 100;
Между ними есть важная разница:
| Способ | Что происходит |
|---|---|
#define |
препроцессор выполняет текстовую замену до компиляции |
const |
создаётся объект языка C, доступный только для чтения |
В начальном курсе удобно использовать #define для размеров
массивов, условной компиляции и препроцессорных настроек.
Для обычных типизированных констант часто лучше подходит
const, потому что компилятор видит тип такого объекта.
Плохая идея: заменять синтаксис языка
С помощью #define технически можно заменить одни слова
другими и даже имитировать другой синтаксис.
#define begin {
#define end }
int main(void)
begin
printf("Hello\n");
return 0;
end
После препроцессорной обработки это превратится в обычный C-код с фигурными скобками.
Но для учебного и рабочего кода так делать не стоит. Такой стиль:
- путает читателя;
- мешает привыкнуть к настоящему синтаксису C;
- может ухудшить подсветку синтаксиса в редакторе;
- затрудняет поиск ошибок;
- делает код менее привычным для других программистов.
Лучше писать стандартно:
int main(void)
{
printf("Hello\n");
return 0;
}
Типичные ошибки
Ошибка 1. Точка с запятой внутри #define
#define SIZE 100;
Точка с запятой станет частью подстановки. Обычно правильно так:
#define SIZE 100
Ошибка 2. Макрос-выражение без скобок
#define SQUARE_SUM a + b
Если такое выражение использовать рядом с умножением или делением, результат может быть неожиданным. Лучше:
#define SQUARE_SUM ((a) + (b))
Макросы с параметрами будут подробно изучаться позже, но привычку ставить скобки вокруг выражений нужно формировать уже сейчас.
Ошибка 3. Ожидание замены внутри строки
#define NAME Ivan
printf("NAME");
На экран будет выведено NAME, а не Ivan,
потому что внутри строкового литерала замена не выполняется.
Ошибка 4. Ожидание замены внутри другого идентификатора
#define MAX 100
int MAX_VALUE = 10;
Имя MAX_VALUE не превратится в 100_VALUE.
Замена выполняется только для отдельной лексемы MAX.
Ошибка 5. Слишком короткие имена макросов
#define N 100
#define A 10
#define X 5
Короткие имена легко случайно использовать в другом смысле. Для констант лучше выбирать более понятные имена:
#define MAX_SIZE 100
#define DEFAULT_COUNT 10
#define BUFFER_LENGTH 256
Ошибка 6. Скрывать сложный код за #define
#define DO_ALL readData(); processData(); printResult()
Такой макрос ухудшает читаемость. Лучше оформить последовательность действий как обычную функцию.
Практические рекомендации
- Используй
#defineв основном для простых препроцессорных констант. - Пиши имена макросов заглавными буквами:
MAX_SIZE,BUFFER_SIZE. - Не ставь точку с запятой после обычного
#define. - Если строка замещения является выражением, заключай её в скобки.
- Не жди замен внутри строк, символов, комментариев и частей идентификаторов.
- Не заменяй через
#defineбазовый синтаксис языка. - Для повторяющихся действий чаще используй функции, а не макросы.
- Если нужно переопределить имя, сначала явно используй
#undef. - Держи препроцессорные определения в начале файла, если нет причины делать иначе.
- Проверяй результат препроцессорной обработки через
gcc -E, если поведение макроса непонятно.
Мини-разбор программы
#include <stdio.h>
#include <limits.h>
#define MAX_SIZE 5
#define RANGE ((INT_MAX) - (INT_MIN) + 1)
#define MESSAGE "Array processing"
int main(void)
{
int numbers[MAX_SIZE] = { 1, 2, 3, 4, 5 };
int i;
int sum = 0;
printf("%s\n", MESSAGE);
printf("int range = %u\n", RANGE);
for (i = 0; i < MAX_SIZE; i++)
{
sum += numbers[i];
}
printf("sum = %d\n", sum);
return 0;
}
Разберём программу:
MAX_SIZEзаменяется на5и используется как размер массива;RANGEзаменяется на выражение для диапазона значений типаint;MESSAGEзаменяется на строковый литерал;MAX_SIZEв условии цикла тоже заменяется на5;- внутри строкового литерала текст не заменяется;
- после препроцессорной обработки компилятор получает обычный C-код без этих директив.
Что нужно запомнить
#defineзадаёт текстовую замену до компиляции.- Общая форма:
#define идентификатор строка_замещения. - Действие
#defineобычно продолжается от места определения до конца файла. #defineне создаёт переменную.- После обычного
#defineне ставят точку с запятой. - Замена выполняется только для отдельной лексемы.
- Замены не выполняются внутри комментариев, строковых литералов и символьных констант.
- Часть идентификатора не заменяется.
- Если строка замещения содержит уже определённый идентификатор, возможна цепочка подстановок.
- Длинную строку замещения можно продолжить обратной косой чертой в конце строки.
#undefотменяет определение препроцессорного идентификатора.- Для обычных типизированных констант часто удобнее
const, а для препроцессорных настроек —#define.
Самопроверка перед переходом дальше
- Для чего используется директива
#define? - Почему
#define SIZE 100не создаёт переменную? - Где обычно размещают препроцессорные определения?
- Почему после
#define SIZE 100не ставят точку с запятой? - Будет ли заменено слово
SIZEвнутри строки"SIZE"? - Будет ли заменена часть имени
SIZE_VALUE, если определён макросSIZE? - Что такое цепочка подстановок?
- Зачем заключать макрос-выражение в скобки?
- Как перенести длинную строку замещения на следующую строку?
- Что делает директива
#undef? - Чем
#defineотличается отconst? - Почему не стоит заменять через
#defineсинтаксис языка C?