Подобное функции макроопределение в C

Рассмотрим:

int x = rand()
int y = foo( x );

x неизвестен во время компиляции.

Вы можете сделать следующее

#define foo(x) ((x) > 32 ? (x) : (2 * (x)))

Но это оценивает x несколько раз. Вместо этого вы можете создать статическую функцию, что чище

static int foo(int x) {
  if(x > 32) 
    return x;
  return 2 * x;
}

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

То, что вы написали, использует директивы препроцессора #if, #else и #endif, но вам нужно использовать языковые конструкции, если вы передаете переменные в макрос и хотите оценить их значения. Использование операторов if и else как настоящих языковых конструкций также не работает, потому что операторы потока управления не оценивают значения. Другими словами, оператор if управляет только потоком управления ("если A, то выполнить B, иначе выполнить C"), не оценивая никаких значений.

Проблема не в теории: при условии, что вы по какой-то причине хотите иметь макрос, который расширяется по-разному в зависимости от значения переданного ему параметра, и этот параметр является константа, известная препроцессору макроса, нет причин, по которым она не может работать ... для универсального макропроцессора ... Но, к сожалению, cpp не допускает присутствие других "команд" макропроцессора в определении макроса ...

Таким образом, ваш

#define foo(x) \
#if x>32 \
  x      \
#else    \
  2*x    \
#endif

не расширяется до

#if X>32
  X
#else
  2*X
#endif

, где X - известный параметр (поэтому измените X на, например, 31), что требует еще одного прохода препроцессором.

Более того, новые строки игнорируются, хотя они важны для такого использования; в противном случае следующий трюк (который, однако, требует еще одного прохода предварительной обработки)

#define foo(x,y) \
y if x>32 \
  x  \
y else \ 
  2*x \
y endif

, который с foo (20, #) производит

# if 20>32 20 # else 2*20 # endif

, который будет работать, если он будет

# if 20>32
  20
# else
  2*20
# endif

... но это не так (и, как уже говорилось, выходные данные препроцессора должны быть снова переданы препроцессору ...)

Итак, я отвечаю, что если вам нужны эти вещи, вы не можете использовать препроцессор C. ; вам следует использовать необычный (не стандартный?) препроцессор C или просто другой макропроцессор, и если вам нужны вещи, которые "cpp" должен "интегрировать" с C, то вы не можете использовать общий препроцессор ( как M4) так легко ...

int a = foo(31);

Расширяется до

int a = if 31>32
31
else
(2*31)
endif;

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

Учитывая это, легко понять, почему ваш код не работает. Альтернативой, которая была бы достаточной для этого примера, была бы следующая:

#define foo(x) (x > 32 ? x : 2*x)

С другой стороны, я бы поставил под сомнение, действительно ли макросы являются подходящим инструментом для таких вещей с самого начала. Просто вставьте его в функцию, и компилятор встроит код, если посчитает, что это ускорит его.

#define \
    foo(x) \
    ({ \
        int xx = (x); \
        int result = (xx > 32) ? xx : (2*xx); \
        result; \
    })