3.2. Замены в тексте

Теория

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

Препроцессор может выполнять текстовые замены до того, как программа будет передана компилятору. Для этого используется директива #define.

С помощью #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-код с фигурными скобками.

Но для учебного и рабочего кода так делать не стоит. Такой стиль:

Лучше писать стандартно:

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()

Такой макрос ухудшает читаемость. Лучше оформить последовательность действий как обычную функцию.

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

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

#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;
}

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

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

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

  1. Для чего используется директива #define?
  2. Почему #define SIZE 100 не создаёт переменную?
  3. Где обычно размещают препроцессорные определения?
  4. Почему после #define SIZE 100 не ставят точку с запятой?
  5. Будет ли заменено слово SIZE внутри строки "SIZE"?
  6. Будет ли заменена часть имени SIZE_VALUE, если определён макрос SIZE?
  7. Что такое цепочка подстановок?
  8. Зачем заключать макрос-выражение в скобки?
  9. Как перенести длинную строку замещения на следующую строку?
  10. Что делает директива #undef?
  11. Чем #define отличается от const?
  12. Почему не стоит заменять через #define синтаксис языка C?