| Каталог документации / Раздел "Программирование, языки" / Оглавление документа |
| |
|
Макрос это тип сокращения, который можно заранее определить и использовать в дальнейшем. Существует довольно много возможностей, связанных с использованием макросов в С препроцессоре.
"Простой макрос" это тип сокращения. Это идентификатор, который используется для представления фрагмента кода.
Перед использованием макроса его необходимо определить с помощью директивы '#define', за которой следует название макроса и фрагмент кода, который будет идентифицировать этот макрос. Например,
#define BUFFER_SIZE 1020
foo = (char *) xmalloc (BUFFER_SIZE);
foo = (char *) xmalloc (1020);
Обычно, макроопределением должна быть отдельная строка, как и при использовании всех директив препроцессора. (Длинное макроопределение можно разбить на несколько строк с применением последовательности backslash-newline.) Хотя существует одно исключение: символы перевода строки могут быть вкючены в макроопределение если они находятся в строковой или символьной константе, потому как макроопределение не может содержать каких-либо специальных символов. Макроопределение автоматически дополняется соответствующим специальным символом, который завершает строчную или символьную константу. Комментарии в макроопределениях могут содержать символы перевода строки, так как это ни на что не влияет, потому как все комментарии полностью заменяются пробелами вне зависимости от того, что они содержат.
В отличие от выше сказанного, не существует никаких ограничений на значение макроса. Скобки не обязательно должны закрываться. Тело макроса не обязательно должно содержать правильный С код.
Препроцессор С обрабатывает программу последовательно, поэтому макроопределения вступают в силу только в местах, где они используются. Поэтому, после обработки следующих данных С препроцессором
foo = X;
#define X 4
bar = X;
foo = X;
bar = 4;
#define BUFSIZE 1020
#define TABLESIZE BUFSIZE
Это не является тем же, что и определение макроса 'TABLESIZE' равным значению '1020'. Директива '#define' для макроса 'TABLESIZE' использует в точности те данные, которые были указаны в ее теле и заменяет макрос 'BUFSIZE' на его значение.
Значение простого макроса всегда одно и то же при каждом его использовании. Макросы могут быть более гибкими, если они принимают аргументы. Аргументами являются фрагменты кода, которые прилагаются при каждом использовании макроса. Эти фрагменты включаются в расширение макроса в соответствии с указаниями в макроопределении.
Для определения макроса, использующего аргументы, применяется директива '#define' со списком имен аргументов в скобках после имени макроса. Именами аргументов могут быть любые правильные С идентификаторы, разделенные запятыми и, возможно, пробелами. Открывающаяся скобка должна следовать сразу же после имени макроса без каких-либо пробелов.
Например, для вычисления минимального значения из двух заданных можно использовать следующий макрос:
#define min(X, Y) ((X) < (Y) ? (X) : (Y))
Значение макроса зависит от используемых аргументов. Каждое имя аргумента во всем макроопределении заменяется на значения соответствующих указанных аргументов. При использовании макроса 'min', рассмотренного ранее, следующим образом:
min (1, 2)
((1) < (2) ? (1) : (2))
При указании аргументов, скобки должны закрываться, а запятая не должна завершать аргумент. Однако, не существует каких либо ограничений на использование квадратных или угловых скобок. Например
macro (array[x = y, x + 1])
После подстановки указанных аргументов в тело макроса, полученный в результате текст добавляется к началу оставшихся данных и производится проверка на наличие других вызовов макросов. Поэтому указываемые аргументы могут содержать ссылки к другим макросам как с аргументами, так и без, а также к тому же макросу. Тело макроса также может включать ссылки к другим макросам. Например, макрос 'min (min (a, b), c)' заменяется следующим текстом:
((((a) < (b) ? (a) : (b))) < (c)
? (((a) < (b) ? (a) : (b)))
: (c))
Если макрос 'foo' принимает один аргумент и нужно передать ему пустой аргумент, то в скобках следует указать по крайней мере один пробел: 'foo ( )'. Если пробел не указывать, а макрос 'foo' требует один аргумент, то произойдет ошибка. Для вызова макроса, не принимающего аргументы, можно использовать конструкцию 'foo0()' как рассмотрено ниже:
#define foo0() ...
Подобное двойственное использование одного имени может привести к осложнениям и его следует избегать, за исключением случаев, когда оба значения являются синонимами, то есть когда под одним именем определена функция и макрос и оба выполняют одинаковые действия. Можно рассматривать это имя как имя функции. Использование имени не для ссылки (например, для получения адреса) приведет к вызову функции, в то время как ссылка приведет к замене имени на значение макроса и в результате будет получен более эффективный но идентичный код. Например, используется функция с именем 'min' в том же исходном файле, где определен макрос с тем же именем. Если написать '&min' без списка аргументов, то это приведет к вызову функции. Если же написать 'min (x, bb)' со списком аргументов, то вместо этого будет произведена замена на значение соответствующего макроса. Если использовать конструкцию '(min) (a, bb)', где за именем 'min' не следует открывающаяся скобка, то будет произведен вызов функции 'min'.
Нельзя определять простой макрос и макрос с аргументами с одним именем.
В определении макроса с аргументами список аргументов должен следовать сразу после имени макроса без пробелов. Если после имени макроса стоит пробел, то макрос определяется без аргументов, а остальная часть строки становится значением макроса. Причиной этому является то, что довольно часто определяются макросы без аргументов. Определение макросов подобным образом позволяет выполнять такие операции как
#define FOO(x) - 1 / (x)
#define BAR (x) - 1 / (x)
Некоторые простые макросы являются заранее определенными. Их можно применять без предварительного определения. Они разделяются на два класса: стандартные макросы и системно-зависимые макросы.
Стандартные заранее определенные макросы могут применяться вне зависимости от используемой платформы или операционной системы на которой функционирует GNU C. Их имена начинаются и заканчиваются двойным символом подчеркивания. Все макросы в следующем списке до '__GNUC__' являются стандартизированными ANSI C. Остальные макросы являются расширениями GNU C.
Этот макрос заменяется на имя текущего исходного файла в форме строковой константы С. Возвращаемым именем является одно из указанных в директиве '#include' или имя основного исходного файла.
Этот макрос заменяется на номер текущей строки в форме десятичной целой константы. В то время как он называется заранее определенным макросом, его значение меняется динамически.
Этот макрос и макрос '__FILE__' используются при генерировании сообщения об ошибке для вывода несоответствия, определенного программой. Сообщение может содержать номер строки исходного файла где была обнаружена ошибка. Например,
fprintf (stderr, "Internal error: "
"negative string length "
"%d at %s, line %d.",
length, __FILE__, __LINE__);
Значения '__FILE__' и '__LINE__' изменяются при использовании директивы '#line'.
Этот макрос заменяется на строчную константу, которая указывает дату запуска препроцессора. Эта константа содержит одинадцать символов и выглядит примерно так '"Jan 29 1987"' или '"Apr 1 1905"'.
Этот макрос заменяется на строковую константу, которая указывает время запуска препроцессора. Константа содержит восемь символов и выглядит примерно так: '"23:59:01:'.
Этот макрос заменяется на константу со значением 1 для указания, что это С стандарта ANSI.
Этот макрос заменяется на номер версии стандарта С, длинной целой константой в форме 'YYYYMML', где YYYY и MM год и месяц выхода версии стандарта. Это указывает на версию стандарта С, к которой относится препроцессор.
Этот макрос определен тогда и только тогда, когда используется GNU C. Он определен только тогда используется полный GNU C компилятор. Если вызвать препроцессор отдельно, то этот макрос будет не определен. Его значение указывает на основной номер версии GNU CC ('1' для версии 1 GNU CC, которая уже является устаревшей, и '2' для версии 2).
Этот макрос содержит дополнительный номер версии компилятора. Он может быть использован при работе с отличительными возможностями различных выпусков компилятора.
Компилятор GNU C определяет этот макрос если компилируемым языком является С++.
Стандарт ANSI для С++ раньше требовал определения этой переменной. Хотя ее наличие больше не требуется, в GNU C++ она все еще определяется, как и в других известных компиляторах С++. Этот макрос может быть использован для определения каким компилятором был скомпилирован заголовок (С или С++).
Этот макрос определяется тогда и только тогда, когда при вызове GNU C указывается опция '-ansi'. Он определяется как пустая строка.
Этот макрос заменяется на имя основного исходного файла в форме строковой константы С. Это исходный файл, указываемый в качестве параметра при вызове компилятора С.
Этот макрос заменяется на десятичную целую константу, которая указывает на уровень вложенности подключаемых файлов. Его значение увеличивается на единицу при обработке директивы '#include' и уменьшается на единицу при завершении обработки каждого файла. Начальное значение для файлов, указываемых в командной строке при вызове компилятора является равным нулю.
Этот макрос заменяется сторокой, указывающей номер версии GNU C. Обычно это последовательность десятичных чисел, разделенных точками. Например '"2.6.0"'.
Этот макрос определяется в оптимизирующих компиляторах. Если но определен, то это приводит к созданию в подключаемых файлах GNU альтернативных макроопределений для некоторых функций из системных библиотек. Проверка или использование значения этого макроса не имеет особого смысла, до тех пор, пока не будет полной уверенности в том, что программы будут выполняться с таким же эффектом.
Этот макрос определяется тогда и только тогда, когда тип данных 'char' является беззнаковым. Он реализован для правильного функционирования подключаемого файла 'limit.h'. Не следует использовать этот макрос. Вместо этого можно использовать стандартные макросы, определенные в файле 'limit.h'. Препроцессор использует этот макрос для определения необходимости в добавлении знакового бита в больших восьмеричных символьных константах.
Этот макрос заменяется на сроку, описывающую префикс, добавляемый к обозначению регистров процессора в ассемблерном коде. Он может использоваться для написания ассемблерного кода, функционирующего в различных оболочках. Например, в оболочке 'm68k-aout' производится замена на строку '""', а в оболочке 'm68k-coff' макрос заменяется на строку '"%"'.
Этот макрос заменяется на строку, описывающую префикс, добавляемый к меткам пользователя в ассемблерном коде. Он может использоваться для написания ассемблерного кода, функционирующего в различных оболочках. Например, в оболочке 'm68k-out' он заменяется на строку '" "', а в оболочке 'm68k-coff' - на строку '""'.
Обычно С препроцессор имеет несколько заранее определенных макросов, значения которых различаются в зависимости от используемой платформы и операционной системы. В данном руководстве не представляется возможным рассмотреть все макросы. Здесь описаны только наиболее типичные из них. Для просмотра значений заранее определенных макросов можно воспользоваться командой 'cpp -dM'.
Некоторые нестандартные заранее определенные макросы более или менее подробно описывают тип используемой операционной системы. Например,
Этот макрос обычно определен на всех системах Unix.
Этот макрос определен на последних версиях системы Berkley Unix (возможно только в версии 4.3).
Другие макросы описывают тип центрального процесора. Например,
Определен на Vax компьютерах.
Определен на большинстве компьютеров, использующих процессор Motorola 68000, 68010 или 68020.
Также определен на большинстве компьютеров с процессором 68000, 68010 или 68020. Хотя некоторые разработчики используют 'mc68000', а некоторые - 'm68k'. Некоторые заранее определяют оба макроса.
Определен на некоторых системах с процессором 68020 в дополнение к макросам 'mc68000' и 'm68k', которые являются менее специфичными.
Определены на компьютерах с процессорами из семейства AMD 29000.
Определен на компьютерах, использующих процессоры серии National Semiconductor 32000.
Другие нестандартные макросы описывают изготовителей компьютерных систем. Например,
Определен на всех моделях компьютеров Sun.
Определен на всех моделях компьютеров Pyramid.
Определен на всех моделях компьютеров Sequent.
Это приводит к тому, что опция '-ansi' становится бесполезной, так как большое количество программ зависит от нестандартных заранее определенных символов. Даже системные подключамые файлы проверяют их значения и генерируют неправильные объявления в случае если требуемые имена не определены. В результате очень мало программ компилируется с опцией '-ansi'.
Что же нужно сделать в ANSI C программе для того, чтобы проверить тип используемого компьютера?
Для этой цели GNU C предоставляет параллельную серию символов, имена которых состоят из обычных символов с добавлением строки '__' с начала и с конца. Таким образом символ '__vax__' используется на системах Vax, и так далее.
Набор нестандартных заранее определенных символов в GNU C препроцессоре изменяется (при компиляции самого компилятора) с помощью макроса 'CPP_PREDEFINES', которым является строка, состоящая из опций '-D', разделенных пробелами. Например, на системе Sun 3 используется следующее макроопределение:
#define CPP_PREDEFINES "-Dmc68000 -Dsun -Dunix -Dm68k"
"Стрингификация" означает преобразование фрагмента кода в строковую константу, которая содержит текст этого фрагмента кода. Например, в результате стрингификации 'foo (z)' получается '"foo (z)"'.
В С препроцессоре, стрингификация является опцией, используемой при замене аргументов в макросе макроопределением. При появлении имени аргумента в теле макроопределения, символ '#' перед именем аргумента указывает на стрингификацию соответствующего аргумента при его подстановке в этом месте макроопределения. Этот же аргумент может быть заменен в другом месте макроопределения без его стрингификации, если перед именем аргумента нет символа '#'.
Вот пример макроопределения с использованием стрингификации:
#define WARN_IF(EXP) \
do { if (EXP) \
fprintf (stderr, "Warning: " #EXP "\n"); } \
while (0)
Возможности срингификации ограничены до преобразования одного макро аргумента в одну строковую константу: не существует методов комбинирования аргумента с другим текстом и посследующей стрингификации полученных данных. Хотя рассмотренный выше пример показывает как может быть достигнут подобный результат в стандартном ANSI C с использованием возможности объединения смежных строковых констант в одну. Препроцессор стрингифицирует реальное значение 'EXP' в отдельную строковую константу и в результате получается следующий текст:
do { if (x == 0) \
fprintf (stderr, "Warning: " "x == 0" "\n"); } \
while (0)
do { if (x == 0) \
fprintf (stderr, "Warning: x == 0\n"); } \
while (0)
Пробелы (включая комментарии), находящиеся в тексте, обрабатываются в соответствии с установленными правилами. Все предшествующие и последующие пробелы игнорируются. Любые последовательности пробелов в середине текста в результате обработки заменяются на отдельный пробел.
"Объединение" означает соединение двух строковых констант в одну. При работе с макросами, это означает объединение двух лексических единиц в одну более длинную. Один аргумент макроса может быть объединен с другим аргументом или с каким-либо текстом. Полученное значение может быть именем функции, переменной или типа, а также ключевым словом С. Оно даже может быть именем другого макроса.
При определении макроса, проверяется наличие операторов '##' в его теле. При вызове макроса и после подстановки аргументов все операторы '##', а также все пробелы рядом с ними (включая пробелы, принадлежащие аргументам) удаляются. В результате производится объединение синтаксических конструкций с обоих сторон оператора '##'.
Рассмотрим С программу, интерпретирующую указываемые команды. Для этого должна существовать таблица команд, возможно массив из структур, описанный следующим образом:
struct command
{
char *name;
void (*function) ();
};
struct command commands[] =
{
{ "quit", quit_command},
{ "help", help_command},
...
};
#define COMMAND(NAME) { #NAME, NAME ## _command }
struct command commands[] =
{
COMMAND (quit),
COMMAND (help),
...
};
Следует заметить, что препроцессор С преобразует все комментарии в пробелы перед обработкой макросов. Поэтому нельзя создать комментарий путем объединения '/' и '*' так как последовательность символов '/*' не является лексической конструкцией. Также можно использовать комментарии в макроопределениях после строки '##' или в объединяемых аргументах, так как сначала комментарии заменяются на пробелы, а при объединении эти пробелы игнорируются.
"Удалить" макрос означает отменить его определение. Это производится с помощью директивы '#undef', за которой следует имя макроса.
Как и определение, удаление макросов появляется в определенном месте исходного файла и вступает в силу с этого места. Например,
#define FOO 4
x = FOO;
#undef FOO
x = FOO;
x = 4;
x = FOO;
Директива '#undef' используется в такой же форме и для отмены макроопределений с аргументами или без них. Применение этой директивы к неопределенному макросу не дает никакого эффекта.
"Переопределение" макроса означает определение (с помощью директивы '#include') имени, которое уже было определено как макрос.
Переопределение явялется простым, если новое определение явно идентично старому. Иногда не требуется специально выполнять простое переопределение, хотя оно производится автоматически, если подключаемый файл вкючается более одного раза, поэтому оно выполняется без какого-либо эффекта.
Нетривиальные переопределения рассматриваются как возможная ошибка, поэтому в таких случаях препроцессор выдает предупреждающее сообщение. Однако, это иногда помогает при изменении определения макроса во время предварительной компиляции. Появление предупреждающего сообщения можно запретить путем предварительного уничтожения макроса с помощью директивы '#undef'.
Для простого переопределения новое определение долно точно совпадать с предыдущим значением за исключением двух случаев:
В начале и в конце определения могут быть добавлены или удалены пробелы.
Пробелы можно изменять в середине определения (но не в середине строки). Однако они не могут быть полностью удалены, а также не могут быть вставлены туда, где их не было вообще.
В этом разделе рассматриваются некоторые специальные правила работы, связанные с макросами и макроподстановками, а также указываются отдельные случаи, которые следует иметь в виду.
При вызове макроса с аргументами, они подставляются в тело макроса, а затем просматриваются полученные после подстановки данные вместе с оставшейся частью исходного файла на предмет дополнительных макро вызовов.
Возможно объединение макро вызова, исходящего частично от тела макроса и частично - от аргументов. Например,
#define double(x) (2*(x))
#define call_with_1(x) x(1)
Макроопределения не обязательно должны иметь закрывающиеся скобки. Путем использования не закрывающейся скобки в теле макроса возможно создание макро вызова, начинающегося в теле макроса и заканчивающегося вне его. Например,
#define strange(file) fprintf (file, "%s %d",
...
strange(stderr) p, 35)
Во большинстве примеров макроопределений, рассмотренных выше, каждое имя макроаргумента заключено в скобки. В дополнение к этому, другая пара скобок используется для заключения в них всего макроопределения. Далее описано, почему лучше всего следует писать макросы таким образом.
Допустим, существует следующее макроопределение:
#define ceil_div(x, y) (x + y - 1) / y
a = ceil_div (b & c, sizeof (int));
a = (b & c + sizeof (int) - 1) / sizeof (int);
a = (b & (c + sizeof (int) - 1)) / sizeof (int);
a = ((b & c) + sizeof (int) - 1)) / sizeof (int);
#define ceil_div(x, y) ((x) + (y) - 1) / (y)
Однако, нестандартная группировка может привести к другому результату. Рассмотрим выражение 'sizeof ceil_div(1, 2)'. Здесь используется выражение С, вычисляющее размер типа данных 'ceil_div(1, 2)', но в действительности производятся совсем иные действия. В данном случае указанная срока заменяется на следующую:
sizeof ((1) + (2) - 1) / (2)
Заключение в скобки всего макроопределения позволяет избежать подобных проблем. Далее дан правильный пример определения макроса 'ceil_div'.
#define ceil_div(x, y) (((x) + (y) - 1) / (y))
Иногда требуется определять макросы, используемые в составных конструкциях. Рассмотрим следующий макрос, который использует указатель (аргумент 'p' указывает его местоположение):
#define SKIP_SPACES (p, limit) \
{ register char *lim = (limit); \
while (p != lim) { \
if (*p++ != ' ') { \
p--; break; }}}
Вызов этого макроса может выглядеть так: 'SKIP_SPACES (p, lim)'. Грубо говоря, при его вызове он заменяется на составную конструкцию, которая является полностью законченной и нет необходимости в использовании точки с запятой для ее завершения. Но вызов этого макроса выглядит как вызов функции. Поэтому удобнее будет вызывать этот макрос следующим образом: 'SKIP_SPACES (p, lim);'
Но это может привести к некоторым трудностям при использовании его перед выражением 'else', так как точка с запятой является пустым выражением. Рассмотрим такой пример:
if (*p != 0)
SKIP_SPACES (p, lim);
else ...
Определение макроса 'SKIP_SPACES' может быть изменено для устранения этого недостатка с использованием конструкции 'do ... while'.
#define SKIP_SPACES (p, limit) \
do { register char *lim = (limit); \
while (p != lim) { \
if (*p++ != ' ') { \
p--; break; }}} \
while (0)
do {...} while (0);
Во многих С программах определяется макрос 'min' для вычисления минимума:
#define min(X, Y) ((X) < (Y) ? (X) : (Y))
next = min (x + y, foo (z));
next = ((x + y) < (foo (z)) ? (x + y) : (foo (z)));
Функция 'foo' используется в этой конструкции только один раз, в то время как выражение 'foo (z)' используется дважды в макроподстановке. В результате функция 'foo' может быть вызвана дважды при выполнении выражения. Если в макросе имеются побочные эффекты или для вычисления значений аргументов требуется много времени, результат может быть неожиданным. В данном случае макрос 'min' является ненадежным.
Наилучшим решением этой проблемы является определение макроса 'min' таким образом, что значение 'foo (z)' будет вычисляться только один раз. В языке С нет стандартных средств для выполнения подобных задач, но с использованием расширений GNU C это может быть выполнено следующим образом:
#define min(X, Y) \
({ typeof (X) __x = (X), __y = (Y); \
(__x < __y) ? __x : __y; })
#define min(X, Y) ((X) < (Y) ? (X) : (Y))
...
{
int tem = foo (z);
next = min (x + y, tem);
}
"Рекурсивные" макросы - это макросы, в определении которых используется имя самого макроса. Стандарт ANSI C не рассатривает рекурсивный вызов макроса как вызов. Он поступает на вывод препроцессора без изменений.
Рассмотрим пример:
#define foo (4 + foo)
Следуя обычным правилам, каждая ссылка на 'foo' заменяется на значение '(4 + foo)', затем это значение просматривается еще раз и заменяется на '(4 + (4 + foo))' и так далее, пока это не приведет к ошибке (memory full) препроцессора.
Однако, правило об использовании рекурсивных макросов завершит этот процесс после получения результата '(4 + foo)'. Поэтому этот макрос может использоваться для прибавления 4 к значению переменной 'foo'.
В большинстве случаев не следует опираться на эту возможность. При чтении исходных текстов может возникнуть путаница между тем, какое значение является переменной, а какое - вызовом макроса.
Также используется специальное правило для "косвенной" рекурсии. Здесь имеется в виду случай, когда макрос X заменяется на значение 'y', которое является макросом и заменяется на значение 'x'. В результате ссылка на макрос 'x' является косвенной и происходит от подстановки макроса 'x', таким образом, это является рекурсией и далее не обрабатывается. Поэтому после обработки
#define x (4 + y)
#define y (2 * x)
Но предположим, что 'y' используется где-либо еще и не в определении макроса 'x'. Поэтому использование значения 'x' в подстановке макроса 'y' не является рекурсией. Таким образом, производится подстановка. Однако, подстановка 'x' содержит ссылку на 'y', а это является косвенной рекурсией. В результате 'y' заменяется на '(2 * (4 + y))'.
Неизвестно где такие возможности могут быть использованы, но это определено стандартом ANSI C.
Ранее было объяснено, что макроподстановка, включая подставленные значения аргументов, заново просматривается на предмет наличия новых макро вызовов.
Что же происходит на самом деле, является довольно тонким моментом. Сначала значения каждого аргумента проверяются на наличие макро вызовов. Затем полученные значения подставляются в тело макроса и полученная макро подстановка проверяется еще раз на наличие новых макросов.
В результате значения макроаргументов проверяются дважды.
В большинстве случаев это не дает никакого эффекта. Если аргумент содержит какие-либо макро вызовы, то они обрабатываются при первом проходе. Полученное значение не содержит макро вызовов и при втором проходе оно не изменяется. Если же аргументы будут подставлены так, как они были указаны, то при втором проходе, в случае наличия макро вызовов, будет произведена макроподстановка.
Рекурсивный макрос один раз подставляется при первом проходе, а второй раз - при втором. Не подставляемые рекурсивные элементы при выполнении первого прохода отдельно помечаются и поэтому они не обрабатываются при втором.
Первый проход не выполняется, если аргумент образован путем стрингификации или объединения. Поэтому
#define str(s) #s
#define foo 4
str (foo)
При стрингификации и объединении аргумент используется в таком виде, в каком он был указан без последующего просмотра его значения. Этот же аргумент может быть просмотрен, если он указан где-либо еще без использования стрингификации или объединения.
#define str(s) #s lose(s)
#define foo 4
str (foo)
Возникает вопрос: для чего используется два прохода для просмотра макроса и почему бы не использовать один для повышения скорости работы препроцессора. В действительности, здесь есть некоторая разница и она может быть видна в трех отдельных случаях:
Но применение второго прохода приводит к некоторым осложнениям в отдельных случаях при вызовах однородных макросов. Рассмотрим пример:
#define foo a,b
#define bar(x) lose(x)
#define lose(x) (1 + (x))
bar(foo)
#define foo (a,b)
#define bar(x) lose((x))
#define foo { int a, b; ... }
#define foo ({ int a, b; ... })
#define foo { int a; int b; ... }
#define xstr(s) str(s)
#define str(s) #s
#define foo 4
xstr (foo)
"Зависимым" макросом называется макрос, тело которого содержит ссылку на другой макрос. Это довольно часто используется. Например,
#define BUFSIZE 1020
#define TABLESIZE BUFSIZE
Подстановка значения 'TABLESIZE' производится только при использовании этого макроса.
При изменении значения 'BUFSIZE' в каком-либо месте программы ее выполнение меняется. Макрос 'TABLESIZE', определенный как было описано выше, всегда заменяется с использованием значения макроса 'BUFSIZE':
#define BUFSIZE 1020
#define TABLESIZE BUFSIZE
#undef BUFSIZE
#define BUFSIZE 37
При обычной обработке макросов все символы newline в макроаргументах используются при макроподстановке. Это означает, что если некоторые аргументы подставляются более одного раза или вообще не подставляются, то символы newline могут дублироваться. Если подстановка состоит из нескольких конструкций, то в результате порядок строк этих конструкций будет нарушен. Это может привести к неправильным значениям номеров строк в сообщениях об ошибках или при работе с отладчиком.
При работе GNU C препроцессора в режиме ANSI C, им контролируется многократное использование одного аргумента. При первом его использовании подставляются все символы newline, а при последующем использовании эти символы игнорируются. Но даже при работе в таком режиме может возникнуть ошибочная нумерация строк если аргументы используются не в надлежащем порядке или вообще не используются.
Рассмотрим пример:
#define ignore_second_arg(a,b,c) a; c
ignore_second_arg (foo (),
ignored (),
syntax error);
|
Закладки на сайте Проследить за страницей |
Created 1996-2024 by Maxim Chirkov Добавить, Поддержать, Вебмастеру |