Как аккуратно избежать C бросает потерять правду

Question

Я очень рад, что в C, такие вещи, как это плохо код:

(var_a == var_b) ? TRUE : FALSE 

Однако, что это лучший способ справиться с этим:

/* Header stuff */ 
#define INTERESTING_FLAG 0x80000000 
typedef short int BOOL; 

void func(BOOL); 

/* Code */ 
int main(int argc, char *argv[]) 
{ 
     unsigned long int flags = 0x00000000; 

     ... /* Various bits of flag processing */ 

     func(flags & INTERESTING_FLAG); /* func never receives a non-zero value 
             * as the top bits are cut off when the 
             * argument is cast down to a short 
             * int 
             */ 
} 

Допустимо ли (для любого приемлемого использования) (flags & FLAG_CONST) ? TRUE : FALSE?

Answer 1

Я бы предпочел (flags & CONST_FLAG) != 0. Еще лучше используйте тип _Bool, если он у вас есть (хотя он часто замаскирован под bool).

Answer 2

Вы можете избежать этого несколько различных способов:

Во-первых

void func(unsigned long int); 

будет заботиться о нем ...

Или

if(flags & INTERESTING_FLAG) 
{ 
    func(true); 
} 
else 
{ 
    func(false); 
} 

также сделать бы это ,

EDIT: (flags & INTERESTING_FLAG) != 0 также хорош. Наверное, лучше.

Answer 3

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

Answer 4

В любом случае я бы назвал func с (flags & INTERESTING_FLAG) != 0 в качестве аргумента, чтобы указать, что требуется логический параметр, а не арифметический результат flags & INTERESTING_FLAG.

Answer 5

Это частично от темы:

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

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

typedef unsigned long int flagtype; 
... 
inline bool hasInterestingFlag(flagtype flags) { 
    return ((flags & INTERESTING_FLAG) != 0); 
} 

Answer 6

Это не может быть популярным решением, но иногда макросы полезны.

#define to_bool(x) (!!(x)) 

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

func(to_bool(flags & INTERESTING_FLAG)); 

Другой альтернативой может быть определить свой логический тип, чтобы быть intmax_t (от stdint.h), так что это невозможно для значения, которое будет усечено в ложность.

В то время как я здесь, я хочу сказать, что вы должны использовать typedef для определения нового типа, а не #define:

typedef short Bool; // or whatever type you end up choosing 

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

const INTERESTING_FLAG = 0x80000000; 

В целом есть лучшие вещи, на которые вы можете потратить свое время. Но макросы для typedef s немного глупы.

Answer 7

Некоторым людям это не нравится, но я использую !!.

т.е.

!!(flags & CONST_FLAG) 

(не как to_bool макрос, как кто-то другой предложил, просто прямо в коде).

Если больше людей использовали его, это не было бы необычным, так что начните использовать его!

Answer 8

У вас есть что-нибудь против

flags & INTERESTING_FLAG ? TRUE : FALSE 

?

Answer 9

Вот почему вы должны использовать значения только в «логическом» способе, когда эти значения имеют явно логическую семантику. Ваше значение не удовлетворяет правилу taht, поскольку оно имеет выраженную целую семантику (или, точнее, семантику бит-массива). Для того, чтобы преобразовать такое значение булева, сравнить его с 0

func((flags & INTERESTING_FLAG) != 0);