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))
Здесь:
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))
Практические рекомендации
- Не ставь пробел между именем макроса и скобкой в определении макроса с параметрами.
- Заключай каждый параметр макроса в скобки.
- Заключай всё выражение макроса в скобки.
- Не передавай в макросы аргументы с побочными эффектами:
i++,--x, присваивания. - Не используй макрос там, где обычная функция будет понятнее и безопаснее.
- Для отладочного вывода удобно использовать операцию
#. - Операцию
##используй редко и только там, где действительно нужно формировать лексемы. - Для многооператорных макросов используй форму
do { ... } while (0). - Проверяй раскрытие сложных макросов через
gcc -E. - Делай макросы короткими и понятными.
Мини-разбор программы
#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;
}
Разберём программу:
SQUARE(x)формирует выражение для квадрата аргумента;MAX(a, b)выбирает большее из двух выражений;PRINT_INT(x)использует операцию#, чтобы вывести текст выражения;MAX(SQUARE(a), SQUARE(b))сначала раскрывается препроцессором, а затем компилируется как обычное выражение C;- скобки в макросах защищают выражения от ошибок с приоритетами операций.
Что нужно запомнить
- Макрос — это средство текстовой подстановки, выполняемой препроцессором.
- Макрос с параметрами задаётся через
#define имя(параметры) строка_замещения. - Между именем макроса и открывающей скобкой в определении не должно быть пробела.
- Макровызов внешне похож на вызов функции, но обрабатывается до компиляции.
- Макрос не имеет типов параметров.
- Текст макроса вставляется в каждое место его использования.
- Параметры макроса нужно заключать в скобки.
- Всю строку замещения выражения тоже лучше заключать в скобки.
- Макросы могут неожиданно повторно вычислять аргументы.
- В макросы нельзя бездумно передавать
i++,x--и другие выражения с побочными эффектами. - Операция
#превращает аргумент макроса в строковый литерал. - Операция
##склеивает препроцессорные лексемы. - Для обычной логики программы функции обычно безопаснее макросов.
Самопроверка перед переходом дальше
- Что такое макрос?
- Чем макрос с параметрами отличается от простой замены через
#define? - Как записывается макроопределение с параметрами?
- Почему нельзя ставить пробел между именем макроса и открывающей скобкой?
- Что такое макровызов?
- Как раскроется макрос
MAX(x, y)? - Почему параметры макроса нужно заключать в скобки?
- Почему всё выражение макроса тоже лучше заключать в скобки?
- Чем макрос отличается от функции?
- Почему опасно писать
MAX(i++, j)? - Для чего используется операция
#? - Для чего используется операция
##? - Когда лучше использовать функцию вместо макроса?
- Как можно посмотреть результат раскрытия макросов через GCC?