Почему тернарный оператор используется для определения 1 и 0 в макросе?

Я использую SDK для встроенного проекта. В этом исходном коде я нашел код, который, по крайней мере, мне показался странным. Во многих местах в SDK есть исходный код в таком формате:

#define ATCI_IS_LOWER( alpha_char )  ( ( (alpha_char >= ATCI_char_a) && (alpha_char <= ATCI_char_z) ) ? 1 : 0 )

#define ATCI_IS_UPPER( alpha_char )  ( ( (alpha_char >= ATCI_CHAR_A) && (alpha_char <= ATCI_CHAR_Z) ) ? 1 : 0 )

Имеет ли значение использование тернарного оператора здесь?

Не

#define FOO (1 > 0)

такой же как

#define BAR ( (1 > 0) ? 1 : 0)

?

Я попытался оценить это, используя

printf("%d", FOO == BAR);

и получаем результат 1, значит кажется, что они равны. Есть ли причина писать код, как они?

Вы правы, в C тавтологично. Обе ваши конкретные тернарные условные и (1 > 0) имеют тип int.

Но в C ++ это имело бы значение в некоторых любопытных угловых случаях (например, в качестве параметров для перегруженных функций), поскольку ваше тернарное условное выражение имеет тип int, тогда как (1 > 0)имеет тип bool.

Я предполагаю, что автор задумался над этим, чтобы сохранить совместимость с C ++.

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

Не называть имен и не указывать пальцем, но PC-lint - такой инструмент для линтинга .

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

Иногда вы увидите это в очень старом коде, еще до того, как появился стандарт C, который (x > y)оценивает числовые значения 1 или 0; некоторые процессоры предпочли бы вместо этого вычислять -1 или 0, а некоторые очень старые компиляторы могли просто последовать их примеру, поэтому некоторые программисты посчитали, что им нужна дополнительная защита.

Иногда вы также видите это, потому что аналогичные выражения не обязательно оцениваются как числовые 1 или 0. Например, в

#define GRENFELZ_P(flags) (((flags) & F_DO_GRENFELZ) ? 1 : 0)

внутреннее &-выражение оценивается либо как 0, либо как числовое значение F_DO_GRENFELZ, которое, вероятно, не равно 1, поэтому ? 1 : 0служит для его канонизации. Я лично считаю, что проще написать это как

#define GRENFELZ_P(flags) (((flags) & F_DO_GRENFELZ) != 0)

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

В коде SDK есть ошибка, и тройка, вероятно, была кладжем для ее исправления.

В качестве макроса аргументы (alpha_char) могут быть любым выражением и должны быть заключены в круглые скобки, потому что такие выражения, как 'A' && 'c' не пройдут проверку.

#define IS_LOWER( x ) ( ( (x >= 'a') && (x <= 'z') ) ?  1 : 0 )
std::cout << IS_LOWER('A' && 'c');
**1**
std::cout << IS_LOWER('c' && 'A');
**0**

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

Итак, в вашем примере (но с параметрами) они оба ошибаются.

#define FOO(x) (x > 0)
#define BAR(x) ((x > 0) ? 1 : 0)

Правильнее всего их заменить на

#define BIM(x) ((x) > 0)

@CiaPan Обращает внимание на то, что следующий комментарий состоит в том, что использование параметра более одного раза приводит к неопределенным результатам. Например

#define IS_LOWER( x ) (((x) >= 'a') && ((x) <= 'z'))
char ch = 'y';
std::cout << IS_LOWER(ch++);
**1** 
**BUT ch is now '{'**

В C это не имеет значения. Логические выражения в C имеют тип intи значение, равное 0или 1, поэтому

ConditionalExpr ? 1 : 0

не имеет никакого эффекта.

В C ++ это фактически преобразование int, потому что условные выражения в C ++ имеют тип bool.

#include <stdio.h>
#include <stdbool.h>

#ifndef __cplusplus

#define print_type(X) _Generic(X, int: puts("int"), bool: puts("bool") );

#else
template<class T>
int print_type(T const& x);
template<> int print_type<>(int const& x) { return puts("int"); }
template<> int print_type<>(bool const& x) { return puts("bool"); }


#endif

int main()
{
    print_type(1);
    print_type(1 > 0);
    print_type(1 > 0 ? 1 : 0);

/*c++ output:
  int 
  int 
  int

  cc output:
  int
  bool
  int
*/

}

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

Одно простое объяснение состоит в том, что некоторые люди либо не понимают, что условие вернет такое же значение в C, либо думают, что писать проще ((a>b)?1:0).

Это объясняет, почему некоторые также используют подобные конструкции в языках с правильными логическими значениями, которые в C-синтаксисе были бы такими (a>b)?true:false).

Это также объясняет, почему вам не следует менять этот макрос без необходимости.

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