C не имеет встроенных логических типов. Какой лучший способ использовать их в C?

От лучшего к худшему:

Вариант 1 (С99)

#include <stdbool.h>

Вариант 2

typedef enum { false, true } bool;

Вариант 3

typedef int bool;
enum { false, true };

Вариант 4

typedef int bool;
#define true 1
#define false 0

объяснение

• Вариант 1 будет работать, только если вы используете C99, и это «стандартный способ» сделать это. Выберите это, если это возможно.
• Варианты 2, 3 и 4 будут иметь на практике одинаковое поведение. # 2 и # 3 не используют #defines, что, на мой взгляд, лучше.

Если вы не определились, идите с # 1!

Несколько мыслей о логических значениях в C:

Я достаточно intвзрослый , чтобы просто использовать простой s в качестве моего логического типа без каких-либо определений типов, специальных определений или перечислений для значений true / false. Если вы последуете моему предложению никогда не сравнивать с булевыми константами, тогда вам все равно нужно будет использовать 0/1 для инициализации флагов. Однако такой подход может считаться слишком реакционным в эти современные времена. В этом случае, безусловно, следует использовать, <stdbool.h>поскольку он, по крайней мере, имеет преимущество от стандартизации.

Какие бы логические константы ни назывались, используйте их только для инициализации. Никогда не пиши что-то вроде

if (ready == TRUE) ...
while (empty == FALSE) ...

Они всегда могут быть заменены на более четкие

if (ready) ...
while (!empty) ...

Обратите внимание, что они могут быть разумно и понятно прочитаны вслух.

Дайте вашим логическим переменным положительные имена, т.е. fullвместо notfull. Последнее приводит к коду, который трудно прочитать легко. сравнить

if (full) ...
if (!full) ...

с

if (!notfull) ...
if (notfull) ...

Обе первые пары читают естественно, хотя !notfullчитать неловко, как есть, и становится намного хуже в более сложных логических выражениях.

Обычно следует избегать логических аргументов. Рассмотрим функцию, определенную следующим образом

void foo(bool option) { ... }

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

foo(TRUE);
foo(FALSE):

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

typedef enum { OPT_ON, OPT_OFF } foo_option;
void foo(foo_option option);

или

#define OPT_ON true
#define OPT_OFF false
void foo(bool option) { ... }

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

foo(OPT_ON);
foo(OPT_OFF);

что у читателя есть хотя бы шанс понять, не углубляясь в определение foo.

Логическое значение в C является целым числом: ноль для false и ненулевое значение для true.

См. Также логический тип данных , раздел C, C ++, Objective-C, AWK .

Вот версия, которую я использовал:

typedef enum { false = 0, true = !false } bool;

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

Это решает проблему того, что кто-то кодирует что-то, что сводится к следующему:

if (true == !false)

Я думаю, что мы все согласны с тем, что это не очень хорошая практика, но за единовременную стоимость выполнения операции «true =! False» мы устраняем эту проблему.

[РЕДАКТИРОВАТЬ] В конце концов я использовал:

typedef enum { myfalse = 0, mytrue = !myfalse } mybool;

чтобы избежать конфликта имен с другими определяющими схемами trueи false. Но концепция остается прежней.

[EDIT] Чтобы показать преобразование целого числа в логическое значение:

mybool somebool;
int someint = 5;
somebool = !!someint;

Первый (самый правый)! преобразует ненулевое целое число в 0, затем второе (самое левое)! преобразует 0 в myfalseзначение. Я оставлю читателю в качестве упражнения преобразование нулевого целого числа.

[РЕДАКТИРОВАТЬ] Мой стиль заключается в использовании явной установки значения в перечислении, когда требуется конкретное значение, даже если значение по умолчанию будет таким же. Пример: поскольку false должно быть равно нулю, я использую, false = 0,а неfalse,

Если вы используете компилятор C99, он имеет встроенную поддержку типов bool:

#include <stdbool.h>
int main()
{
  bool b = false;
  b = true;
}

http://en.wikipedia.org/wiki/Boolean_data_type

Обо всем по порядку. C, то есть ISO / IEC 9899 имеет логический тип уже 19 лет . Это намного больше времени, чем ожидаемая продолжительность карьеры программиста на Си с любительскими / академическими / профессиональными частями, объединенными при посещении этого вопроса . Моя превосходит это всего лишь на 1-2 года. Это означает, что в то время , когда среднестатистический читатель вообще что-то узнал о C, C фактически имел логический тип данных .

Для типа данных, #include <stdbool.h>и использовать true, falseи bool. Или не включать его и использовать _Bool, 1и 0вместо этого.

В других ответах на эту тему представлены различные опасные методы. Я обращусь к ним:

typedef int bool;
#define true 1
#define false 0

Это нет-нет, потому что случайный читатель - который изучил C в течение этих 19 лет - ожидал, что это boolотносится к фактическому bool типу данных и будет вести себя аналогично, но это не так! Например

double a = ...;
bool b = a;

С C99 bool/ _Bool, bбыло бы установлено, false если бы a был ноль, и в trueпротивном случае. C11 6.3.1.2p1

1. Когда любое скалярное значение преобразуется в _Bool, результат равен 0, если значение сравнивается равным 0; в противном случае результат равен 1. 59)

Сноски

59) NaN не сравниваются равными 0 и, следовательно, преобразуются в 1.

При наличии на typedefместе значение doubleбудет приведено к int- если значение double не находится в диапазоне для int, поведение не определено .

Естественно, то же самое относится, если trueи falseбыли объявлены в enum.

Что еще опаснее, так это декларировать

typedef enum bool {
    false, true
} bool;

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

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

• тип intи значения 0и 1 как есть ; и тщательно делайте доменные преобразования из любых других значений в них с двойным отрицанием!!
• или если вы настаивать вы не помните , что 0 является falsy и ненулевая truish, по крайней мере , использование верхнего регистра , так что они не запутаться с понятиями C99: BOOL, TRUEи FALSE!

typedef enum {
    false = 0,
    true
} t_bool;

C имеет логический тип: bool (по крайней мере, за последние 10 (!) Лет)

Включите stdbool.h, и true / false будет работать как положено.

Все, что не равно нулю, оценивается как истинное в логических операциях, так что вы можете просто

#define TRUE 1
#define FALSE 0

и использовать константы.

Просто дополнение к другим ответам и некоторым разъяснениям, если вам разрешено использовать C99.

+-------+----------------+-------------------------+--------------------+
|  Name | Characteristic | Dependence in stdbool.h |        Value       |
+-------+----------------+-------------------------+--------------------+
| _Bool |   Native type  |    Don't need header    |                    |
+-------+----------------+-------------------------+--------------------+
|  bool |      Macro     |           Yes           | Translate to _Bool |
+-------+----------------+-------------------------+--------------------+
|  true |      Macro     |           Yes           |   Translate to 1   |
+-------+----------------+-------------------------+--------------------+
| false |      Macro     |           Yes           |   Translate to 0   |
+-------+----------------+-------------------------+--------------------+

Некоторые из моих предпочтений:

• _Boolили bool? Оба в порядке, но boolвыглядит лучше, чем ключевое слово _Bool.
• Допустимые значения boolи _Bool: falseили true. Назначение 0или 1вместо falseили trueявляется действительным, но сложнее для чтения и понимания логического потока.

Некоторая информация из стандарта:

• _BoolНЕ unsigned int, но является частью группы целочисленных типов без знака . Он достаточно большой, чтобы содержать значения 0или 1.
• НЕ, но да, вы можете переопределить bool trueи, falseконечно, не очень хорошая идея. Эта способность считается устаревшей и будет удалена в будущем.
• Назначение скалярного типа (арифметические типы и типы указателей) к _Boolили bool, если скалярное значение равно 0или сравнивает 0это будет 0, в противном случае результат 1: _Bool x = 9; 9преобразуется в , 1когда назначен x.
• _Bool1 байт (8 бит), обычно у программиста возникает соблазн попытаться использовать другие биты, но это не рекомендуется, поскольку гарантируется только то, что для хранения данных используется только один бит, а не тип char, имеющий 8 биты доступны.

Вот это:

#define TRUE 1
#define FALSE 0

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

Псевдо-код

#define TRUE  1
#define FALSE 0

char bValue = TRUE;

Вы можете использовать _Bool, но возвращаемое значение должно быть целым числом (1 для true, 0 для false). Тем не менее, рекомендуется включать и использовать BOOL как в C ++, как сказано в этом ответе от daniweb форума , а также этот ответ , от этого другого StackOverflow вопрос:

_Bool: логический тип C99. Использование _Bool напрямую рекомендуется только в том случае, если вы поддерживаете устаревший код, который уже определяет макросы для bool, true или false. В противном случае эти макросы стандартизированы в заголовке. Включите этот заголовок, и вы можете использовать bool, как в C ++.

Условные выражения считаются истинными, если они ненулевые, но стандарт C требует, чтобы сами логические операторы возвращали либо 0, либо 1.

@Tom: #define TRUE! FALSE - это плохо и совершенно бессмысленно. Если заголовочный файл попадает в скомпилированный код C ++, то это может привести к проблемам:

void foo(bool flag);

...

int flag = TRUE;
foo(flag);

Некоторые компиляторы генерируют предупреждение о преобразовании int => bool. Иногда люди избегают этого, делая:

foo(flag == TRUE);

заставить выражение быть C ++ bool. Но если вы #define TRUE! FALSE, вы получите:

foo(flag == !0);

который заканчивает тем, что делает сравнение типа int-to-bool, которое в любом случае может вызвать предупреждение.

Если вы используете C99, то вы можете использовать _Boolтип. Нет #includeнеобходимости. Вы должны рассматривать это как целое число, хотя, где 1есть trueи 0есть false.

Затем вы можете определить TRUEи FALSE.

_Bool this_is_a_Boolean_var = 1;


//or using it with true and false
#define TRUE 1
#define FALSE 0
_Bool var = TRUE;

В настоящее время C99 поддерживает логические типы, но вам нужно #include <stdbool.h>.

Пример:

#include <stdbool.h>

int main() 
{ 
    bool arr[2] = {true, false}; 

    printf("%d\n", arr[0] && arr[1]);
    printf("%d\n", arr[0] || arr[1]);

    return 0; 
} 

Вывод:

0
1

Это то, что я использую:

enum {false, true};
typedef _Bool bool;

_Bool является встроенным типом в C. Он предназначен для логических значений.

Вы можете просто использовать #defineдирективу следующим образом:

#define TRUE 1
#define FALSE 0
#define NOT(arg) (arg == TRUE)? FALSE : TRUE
typedef int bool;

И использовать следующим образом:

bool isVisible = FALSE;
bool isWorking = TRUE;
isVisible = NOT(isVisible);

и так далее