Надлежащая практика программирования для определений макросов (#define) в C

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

#define MIN(a,b)  a < b ? a : b     // WRONG  

int i = MIN(1,2); // works
int i = MIN(1,1+1); // breaks

#define MIN(a,b)  (a) < (b) ? (a) : (b)   // STILL WRONG

int i = MIN(1,2); // works
int i = MIN(1,1+1); // now works
int i = MIN(1,2) + 1; // breaks

#define MIN(a,b)  ((a) < (b) ? (a) : (b))   // GOOD

int i = MIN(1,2); // works
int i = MIN(1,1+1); // now works
int i = MIN(1,2) + 1; // works

Однако MIN(3,i++) все еще сломан...

Лучшее правило - использовать #defines только тогда, когда НИКАКОЙ ДРУГОЙ ПОДХОД НЕ РАБОТАЕТ! Я знаю, что вы спрашиваете о C вместо C++, но все же имейте в виду.

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

 #define DOIT(x) do { x } while(0)

Данная форма имеет следующие преимущества:

1. Нужна завершающая точка с запятой
2. Он работает с вложением и фигурными скобками, например. с если/иначе

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

#define MAX(x, y) ((x) > (y) ? (x) : (y))

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

MAX(a++, b);

Будет оценивать a++ дважды, если a больше, чем b.

Используйте имена макросов в ЗАГЛАВНЫХ РЕГИСТРАХ, чтобы было ясно, что это макрос, а не функция, чтобы различия можно было учитывать соответствующим образом (еще одна общая хорошая практика — не передавать аргументы, которые имеют побочные эффекты, функциям).

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

#define pint int *

потому что он не будет вести себя так, как ожидалось, когда кто-то вводит

pint a, b;

Вместо этого используйте typedefs.

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

static const int DANGER = 60 + 2;

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

#define LESS_THAN(X,Y) (((X) < (Y) ? (X) : (Y))

Ответ на макросы MAX/MIN, взятый из взломов GCC в ядро Linux:

#define min(x, y) ({                       \
        typeof(x) _min1 = (x);             \
        typeof(y) _min2 = (y);             \
        (void) (&_min1 == &_min2);         \
        _min1 < _min2 ? _min1 : _min2; })

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

#define MAX 10

может легко конфликтовать с другим кодом, поэтому:

#define MYPROJECT_MAX 10

или что-то еще более уникальное, было бы лучше.

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

Для многострочных макросов используйте do { } while (0):

#define foo(x) do {  \
    (x)++;           \
    printf("%d", x); \
} while(0)

Вы сделали

#define foo(x) {     \
    (x)++;           \
    printf("%d", x); \
}

вместо,

if (xyz)
    foo(y);
else
    foo(z);

потерпел бы неудачу.

Также будьте осторожны при введении временных переменных в макросы:

#define foo(t) do {    \
    int x = (t);       \
    printf("%d\n", x); \
} while(0)

int x = 42;
foo(x);

напечатает 0, а не 42.

Если у вас есть сложное выражение, которое должно возвращать значение, вы можете использовать оператор запятой:

#define allocate(foo, len) (foo->tmp = foo->head, foo->head += len, foo->tmp)

Отмените определение макросов.

Ваш #defines должен совпадать с #undef. Это предотвращает засорение препроцессора и воздействие на непреднамеренные фрагменты кода.

Если вы внимательны и опытны, вы можете выполнить СУХОЙ (не повторяйте себя) код, используя макросы в качестве простых генераторов кода. Вам нужно объяснять другим программистам, что вы делаете, но это может сэкономить много кода. Например, метод списка макросов:

// define a list of variables, error messages, opcodes
// or anything that you have to write multiple things about
#define VARLIST \
    DEFVAR(int, A, 1) \
    DEFVAR(double, B, 2) \
    DEFVAR(int, C, 3) \

// declare the variables
#define DEFVAR(typ, name, val) typ name = (val);
    VARLIST
#undef  DEFVAR

// write a routine to set a variable by name
void SetVar(string varname, double value){
    if (0);
    #define DEFVAR(typ, name, val) else if (varname == #name) name = value;
        VARLIST
    #undef  DEFVAR
    else printf("unrecognized variable %s\n", varname);
}

// write a routine to get a variable's value, given its name
// .. you do it ..

Теперь, если вы хотите добавить новую переменную, удалить одну или переименовать ее, это редактирование в 1 строку.

Посмотрите, как я ненавижу это:

void bar(void) {
    if(some_cond) {
        #define BAZ ...
        /* some code */
        #undef BAZ
    }
}

Всегда ставьте их так:

void bar(void) {
    if(some_cond) {
#define BAZ ...
        /* some code */
#undef BAZ
    }
}