3.5. Макроподстановки средствами препроцессора

Теория

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

В предыдущих пунктах рассматривались простые текстовые замены через #define. Например, можно было заменить имя MAX_SIZE на число 100.

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

В этом пункте рассматриваются:

Что такое макрос

Макрос — это средство замены одной последовательности символов на другую. Макрос задаётся с помощью директивы #define и обрабатывается препроцессором до компиляции программы.

Простой макрос без параметров:

#define PI 3.14159

double area = PI * r * r;

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

double area = 3.14159 * r * r;

Такой макрос просто заменяет одну лексему на фиксированный текст.

Недостаток простой текстовой замены

Простая замена через #define всегда подставляет один и тот же текст.

#define RANGE ((INT_MAX) - (INT_MIN) + 1)

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

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

max(a, b)
max(x + 1, y)
max(10, value)

Для этого используются макросы с параметрами.

Макроопределение с параметрами

Общая форма макроопределения с параметрами:

#define имя(список_параметров) строка_замещения

Пример:

#define MAX(a, b) ((a) > (b) ? (a) : (b))

Здесь:

Важно: пробел между именем и скобкой

В макроопределении с параметрами между именем макроса и открывающей круглой скобкой не должно быть пробела.

Правильно:

#define MAX(a, b) ((a) > (b) ? (a) : (b))

Неправильно по смыслу:

#define MAX (a, b) ((a) > (b) ? (a) : (b))

Во втором случае препроцессор воспримет MAX как обычный макрос без параметров, а строкой замещения станет весь текст (a, b) ....

Макровызов

Чтобы использовать макрос с параметрами, пишут его имя и список аргументов в круглых скобках.

MAX(x, y)

Если макрос определён так:

#define MAX(a, b) ((a) > (b) ? (a) : (b))

то макровызов:

MAX(x, y)

будет заменён на:

((x) > (y) ? (x) : (y))

А макровызов:

MAX(z, 4)

будет заменён на:

((z) > (4) ? (z) : (4))

Пример: макрос MAX

#include <stdio.h>

#define MAX(a, b) ((a) > (b) ? (a) : (b))

int main(void)
{
    int x = 10;
    int y = 25;

    printf("max = %d\n", MAX(x, y));
    printf("max = %d\n", MAX(x + 100, y));

    return 0;
}

Первый вызов MAX(x, y) выбирает большее из x и y. Второй вызов сравнивает результат выражения x + 100 со значением y.

Пример: макрос ABS

Макрос для получения модуля числа:

#define ABS(x) ((x) < 0 ? -(x) : (x))

Пример использования:

#include <stdio.h>

#define ABS(x) ((x) < 0 ? -(x) : (x))

int main(void)
{
    int a = -10;
    double b = -3.14;

    printf("%d\n", ABS(a));
    printf("%f\n", ABS(b));
    printf("%d\n", ABS(5 - 12));

    return 0;
}

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

Почему параметры нужно заключать в скобки

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

Плохой вариант:

#define SQUARE(x) x * x

Вызов:

SQUARE(a + b)

превратится в:

a + b * a + b

Это не квадрат суммы. Правильнее:

#define SQUARE(x) ((x) * (x))

Тогда:

SQUARE(a + b)

превратится в:

((a + b) * (a + b))

Почему всю строку замещения тоже нужно заключать в скобки

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

Плохой вариант:

#define SUM(a, b) (a) + (b)

int result = 2 * SUM(x, y);

После подстановки:

int result = 2 * (x) + (y);

Умножение выполнится только для x, а не для всей суммы.

Лучше:

#define SUM(a, b) ((a) + (b))

int result = 2 * SUM(x, y);

После подстановки:

int result = 2 * ((x) + (y));

Макрос — не функция

Макрос с параметрами внешне похож на функцию:

MAX(x, y)
ABS(value)
SQUARE(number)

Но работает он не как функция. Функция вызывается во время выполнения программы, а макрос раскрывается препроцессором до компиляции.

Функция Макрос
имеет типы параметров работает с текстом аргументов
вызывается во время выполнения раскрывается до компиляции
тело функции существует в одном экземпляре текст макроса вставляется в каждое место вызова
аргументы вычисляются как выражения аргументы подставляются как текст
компилятор проверяет типы параметров типов параметров у макроса нет

Преимущество макросов

Главное преимущество макроса — он может работать с разными типами, если итоговое выражение корректно для этих типов.

#define MAX(a, b) ((a) > (b) ? (a) : (b))

int i = MAX(3, 7);
double d = MAX(3.14, 2.71);
char c = MAX('A', 'B');

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

Недостаток макросов

Главный недостаток макросов — они могут неожиданно повторно использовать аргументы.

#define MAX(a, b) ((a) > (b) ? (a) : (b))

int x = 5;
int y = 10;

int result = MAX(x++, y);

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

int result = ((x++) > (y) ? (x++) : (y));

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

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

MAX(i++, j)
ABS(x--)
SQUARE(scanf("%d", &n))

Лучше сначала вычислить значение отдельно, а потом передать простую переменную.

Макросы и побочные эффекты

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

i++;
x = 10;
scanf("%d", &n);

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

Практическое правило:

В макросы-выражения передавай простые значения, переменные или выражения без побочных эффектов.

Макрос для доступа к элементу матрицы

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

Например, двумерную матрицу можно хранить в одномерном массиве, а доступ к элементу записывать через макрос:

#define ROWS 4
#define COLS 5
#define A(i, j) x[COLS * ((i) - 1) + ((j) - 1)]

Тогда запись:

A(2, 3)

будет заменена на:

x[COLS * ((2) - 1) + ((3) - 1)]

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

Пример с матрицей через одномерный массив

#include <stdio.h>

#define ROWS 4
#define COLS 5
#define A(i, j) x[COLS * ((i) - 1) + ((j) - 1)]

int main(void)
{
    double x[ROWS * COLS];
    int i;
    int j;
    int k;

    for (k = 0; k < ROWS * COLS; k++)
    {
        x[k] = k + 1;
    }

    for (i = 1; i <= ROWS; i++)
    {
        printf("\nСтрока %d:", i);

        for (j = 1; j <= COLS; j++)
        {
            printf(" %6.1f", A(i, j));
        }
    }

    printf("\n");

    return 0;
}

Здесь A(i, j) выглядит как обращение к элементу матрицы, но после препроцессорной обработки это будет обращение к элементу массива x.

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

Макросы для отладочного вывода

Макросы часто используют для отладочного вывода.

#ifdef DEBUG
#define DEBUG_PRINT(x) printf("DEBUG: %s = %d\n", #x, (x))
#else
#define DEBUG_PRINT(x)
#endif

Если DEBUG определён, макрос выводит имя выражения и его значение. Если DEBUG не определён, макрос раскрывается в пустой текст.

int count = 10;

DEBUG_PRINT(count);

В режиме отладки это может превратиться в вывод:

DEBUG: count = 10

Операция #

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

#define PRINT_EXPR(x) printf(#x " = %d\n", (x))

Вызов:

PRINT_EXPR(a + b);

после макроподстановки станет похож на:

printf("a + b" " = %d\n", (a + b));

Соседние строковые литералы в C объединяются, поэтому результатом будет строка:

"a + b = %d\n"

Пример операции #

#include <stdio.h>

#define PRINT_INT(x) printf(#x " = %d\n", (x))

int main(void)
{
    int a = 10;
    int b = 20;

    PRINT_INT(a);
    PRINT_INT(b);
    PRINT_INT(a + b);

    return 0;
}

Возможный вывод:

a = 10
b = 20
a + b = 30

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

Операция ##

Операция ## склеивает две препроцессорные лексемы в одну. Такой приём называется token pasting, или конкатенацией лексем.

#define MAKE_NAME(prefix, number) prefix##number

Вызов:

MAKE_NAME(value, 1)

будет заменён на:

value1

Это может использоваться для автоматического формирования имён, но такой код нужно писать аккуратно: чрезмерное использование ## ухудшает читаемость.

Пример операции ##

#include <stdio.h>

#define MAKE_VAR(name, number) name##number

int main(void)
{
    int value1 = 10;
    int value2 = 20;

    printf("%d\n", MAKE_VAR(value, 1));
    printf("%d\n", MAKE_VAR(value, 2));

    return 0;
}

После препроцессорной обработки обращения к MAKE_VAR превратятся в имена value1 и value2.

Макросы из нескольких операторов

Иногда макрос должен раскрыться не в одно выражение, а в несколько операторов. Для этого часто используют конструкцию do { ... } while (0).

#define PRINT_TWO(a, b)        \
    do                         \
    {                          \
        printf("%d\n", (a));   \
        printf("%d\n", (b));   \
    } while (0)

Такой макрос можно безопаснее использовать как один оператор:

if (flag)
{
    PRINT_TWO(x, y);
}

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

Когда использовать макрос, а когда функцию

Ситуация Лучше выбрать
нужно обычное вычисление с проверкой типов функцию
нужно повторяющееся действие из нескольких операторов функцию
нужно условно включать код до компиляции макрос + условную компиляцию
нужно сформировать текст выражения для разных типов макрос, но аккуратно
нужно вывести текст самого выражения макрос с операцией #
нужно склеить лексемы макрос с операцией ##

В большинстве учебных программ лучше сначала думать о функции. Макрос стоит использовать тогда, когда действительно нужны возможности препроцессора.

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

Ошибка 1. Пробел между именем макроса и скобкой

#define MAX (a, b) ((a) > (b) ? (a) : (b))

Это не макрос с параметрами. Правильно:

#define MAX(a, b) ((a) > (b) ? (a) : (b))

Ошибка 2. Нет скобок вокруг параметров

#define SQUARE(x) x * x

При вызове SQUARE(a + b) получится неправильное выражение. Правильно:

#define SQUARE(x) ((x) * (x))

Ошибка 3. Нет скобок вокруг всего выражения

#define SUM(a, b) (a) + (b)

Лучше:

#define SUM(a, b) ((a) + (b))

Ошибка 4. Аргумент с побочным эффектом

MAX(i++, j)

Аргумент i++ может быть подставлен и выполнен больше одного раза.

Ошибка 5. Ожидание проверки типов

#define HALF(x) ((x) / 2)

Макрос не знает тип x. Если x целое, деление будет целочисленным. Если нужен вещественный результат, это нужно учитывать:

#define HALF(x) ((x) / 2.0)

Ошибка 6. Слишком сложный макрос

#define PROCESS(a, b, c) read(a); calculate(b); print(c)

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

Ошибка 7. Непонятные имена параметров

#define F(a,b,c) ((a)+(b)*(c))

Если макрос остаётся в программе, лучше сделать имя и параметры понятнее:

#define LINEAR_VALUE(x, k, b) ((k) * (x) + (b))

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

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

#include <stdio.h>

#define SQUARE(x) ((x) * (x))
#define MAX(a, b) ((a) > (b) ? (a) : (b))
#define PRINT_INT(x) printf(#x " = %d\n", (x))

int main(void)
{
    int a = 5;
    int b = 8;
    int result;

    result = MAX(SQUARE(a), SQUARE(b));

    PRINT_INT(a);
    PRINT_INT(b);
    PRINT_INT(result);

    return 0;
}

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

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

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

  1. Что такое макрос?
  2. Чем макрос с параметрами отличается от простой замены через #define?
  3. Как записывается макроопределение с параметрами?
  4. Почему нельзя ставить пробел между именем макроса и открывающей скобкой?
  5. Что такое макровызов?
  6. Как раскроется макрос MAX(x, y)?
  7. Почему параметры макроса нужно заключать в скобки?
  8. Почему всё выражение макроса тоже лучше заключать в скобки?
  9. Чем макрос отличается от функции?
  10. Почему опасно писать MAX(i++, j)?
  11. Для чего используется операция #?
  12. Для чего используется операция ##?
  13. Когда лучше использовать функцию вместо макроса?
  14. Как можно посмотреть результат раскрытия макросов через GCC?