Как расширить определение макросов во время конкатенации? [Дубликат]

Стандартный препроцессор C

$ cat xx.c
#define VARIABLE 3
#define PASTER(x,y) x ## _ ## y
#define EVALUATOR(x,y)  PASTER(x,y)
#define NAME(fun) EVALUATOR(fun, VARIABLE)

extern void NAME(mine)(char *x);
$ gcc -E xx.c
# 1 "xx.c"
# 1 "<built-in>"
# 1 "<command-line>"
# 1 "xx.c"





extern void mine_3(char *x);
$

Два уровня косвенности

В комментарии к другому ответу, Cade Roux спросил почему это требует двух уровней косвенности. Легкий ответ заключается в том, что так стандарт требует от него работы; вы, как правило, обнаруживаете, что вам нужен эквивалентный трюк с оператором стробирования.

Раздел 6.10.3 стандарта C99 охватывает «замену макросов», а 6.10.3.1 охватывает «замену аргументов».

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

В вызове NAME(mine) аргумент «мой»; он полностью расширен до «моего»; он затем заменяется на заменяющую строку:

EVALUATOR(mine, VARIABLE)

Теперь обнаружен макрос EVALUATOR, и аргументы изолированы как «мои» и «ПЕРЕМЕННЫЕ»; последний затем полностью расширяется до «3» и заменяется на заменяющую строку:

PASTER(mine, 3)

. Работа этого распространяется на другие правила (6.10.3.3 «Оператор ##»):

Если в списке замещения функционально-подобного макроса сразу же предшествует или следует токен ## предварительной обработки, этот параметр заменяется на последовательность токенов препроцессора соответствующего аргумента; [...]

Как для объектно-подобных, так и для функции-макросов, перед заменой списка замещения для замены новых имен макросов каждый экземпляр маркера предварительной обработки ## в списке замены (не из аргумента) удаляется, а предыдущий токен предварительной обработки объединяется с следующим токеном предварительной обработки.

Итак, список замены содержит x, а затем ##, а также ##, затем y; поэтому мы имеем:

mine ## _ ## 3

и устраняем токены ## и объединяем маркеры с обеих сторон, комбинируя «мои» с «_» и «3», чтобы получить:

mine_3

Это желаемый результат.

---

Если мы посмотрим на исходный вопрос, код был (адаптирован для использования «mine» вместо «some_function»):

#define VARIABLE 3
#define NAME(fun) fun ## _ ## VARIABLE

NAME(mine)

Аргумент NAME явно «мой», и он полностью расширен. Следуя правилам пункта 6.10.3.3, мы находим:

mine ## _ ## VARIABLE

, который, когда операторы ## устранены, отображает:

mine_VARIABLE

точно так, как указано в вопрос.

---

Традиционный препроцессор C

Роберт Рюгер спрашивает :

Есть ли какой-либо способ сделать это с помощью традиционного препроцессора C, который не имеет оператора для ввода маркера ##?

Возможно, а может и нет - это зависит от препроцессора. Одним из преимуществ стандартного препроцессора является то, что он имеет этот механизм, который работает надежно, тогда как для пре-стандартных препроцессоров были разные реализации. Одним из требований является то, что, когда препроцессор заменяет комментарий, он не генерирует пробел, поскольку требуется препроцессор ANSI. Препроцессор GCC (6.3.0) C соответствует этому требованию; препроцессор Clang из XCode 8.2.1 не работает.

Когда он работает, это выполняет задание (x-paste.c):

#define VARIABLE 3
#define PASTE2(x,y) x/**/y
#define EVALUATOR(x,y) PASTE2(PASTE2(x,_),y)
#define NAME(fun) EVALUATOR(fun,VARIABLE)

extern void NAME(mine)(char *x);

Обратите внимание, что пробела нет между fun, и VARIABLE - это важно, потому что, если он присутствует, он копируется на выход, и вы получаете mine_ 3 как имя, которое не является синтаксически действительным, конечно. (Теперь, пожалуйста, я могу вернуть свои волосы?)

С GCC 6.3.0 (работает cpp -traditional x-paste.c) я получаю:

# 1 "x-paste.c"
# 1 "<built-in>"
# 1 "<command-line>"
# 1 "x-paste.c"





extern void mine_3(char *x);

С Clang из XCode 8.2. 1, я получаю:

# 1 "x-paste.c"
# 1 "<built-in>" 1
# 1 "<built-in>" 3
# 329 "<built-in>" 3
# 1 "<command line>" 1
# 1 "<built-in>" 2
# 1 "x-paste.c" 2





extern void mine _ 3(char *x);

Эти пространства все испортили. Я отмечаю, что оба препроцессора верны; разные пре-стандартные препроцессоры демонстрировали оба поведения, которые делали маркер, вставляя чрезвычайно раздражающий и ненадежный процесс при попытке переноса кода. Стандарт с нотой ## радикально упрощает это.

Могут быть другие способы сделать это. Однако это не работает:

#define VARIABLE 3
#define PASTER(x,y) x/**/_/**/y
#define EVALUATOR(x,y) PASTER(x,y)
#define NAME(fun) EVALUATOR(fun,VARIABLE)

extern void NAME(mine)(char *x);

GCC генерирует:

# 1 "x-paste.c"
# 1 "<built-in>"
# 1 "<command-line>"
# 1 "x-paste.c"





extern void mine_VARIABLE(char *x);

Закрыть, но не кубики. YMMV, конечно, в зависимости от используемого вами пре-стандартного препроцессора. Честно говоря, если вы застряли в препроцессоре, который не сотрудничает, вероятно, будет проще организовать использование стандартного препроцессора C вместо предстандартного (обычно есть способ правильно настроить компилятор), чем потратьте много времени, пытаясь выработать способ выполнить эту работу.

#define VARIABLE 3
#define NAME2(fun,suffix) fun ## _ ## suffix
#define NAME1(fun,suffix) NAME2(fun,suffix)
#define NAME(fun) NAME1(fun,VARIABLE)

int NAME(some_function)(int a);

Честно говоря, вы не хотите знать, почему это работает. Если вы знаете, почему это работает, вы станете этим парнем на работе, который знает такие вещи, и все придут задавать вам вопросы. =)

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