Booleaanse waarden gebruiken in C

C heeft geen ingebouwde booleaanse typen. Wat is de beste manier om ze in C te gebruiken?

Antwoord 1, autoriteit 100%

Van goed tot slecht:

Optie 1 (C99 en nieuwer)

#include <stdbool.h>

Optie 2

typedef enum { false, true } bool;

Optie 3

typedef int bool;
enum { false, true };

Optie 4

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

#Uitleg

• Optie 1 werkt alleen als je C99 (of nieuwer) gebruikt en het is de “standaardmanier” om dit te doen. Kies dit indien mogelijk.
• Opties 2, 3 en 4 zullen in de praktijk hetzelfde identieke gedrag vertonen. #2 en #3 gebruiken #defines echter niet, wat naar mijn mening beter is.

Als je twijfelt, ga dan voor nummer 1!

Antwoord 2, autoriteit 22%

Een paar gedachten over booleans in C:

Ik ben oud genoeg om gewoon ints als mijn boolean-type te gebruiken zonder typedefs of speciale definities of opsommingen voor waar/onwaar-waarden. Als je mijn suggestie hieronder volgt om nooit te vergelijken met booleaanse constanten, dan hoef je alleen 0/1 te gebruiken om de vlaggen toch te initialiseren. Een dergelijke benadering kan in deze moderne tijd echter als te reactionair worden beschouwd. In dat geval moet je zeker <stdbool.h>gebruiken omdat het op zijn minst het voordeel heeft dat het gestandaardiseerd is.

Hoe de booleaanse constanten ook worden genoemd, gebruik ze alleen voor initialisatie. Schrijf nooit iets als

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

Deze kunnen altijd worden vervangen door de duidelijkere

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

Merk op dat deze redelijk en begrijpelijkerwijs hardop kunnen worden uitgelezen.

Geef uw Booleaanse variabelen positieve namen, dwz fullin plaats van notfull. De laatste leidt tot code die moeilijk te lezen is. Vergelijk

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

met

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

Beide van het voormalige paar lezen van nature, terwijl !notfullis ongemakkelijk om te lezen, zelfs als het is, en wordt veel slechter in meer complexe Booleaanse uitdrukkingen.

Booleaanse argumenten moeten over het algemeen worden vermeden. Overweeg een functie die is gedefinieerd

void foo(bool option) { ... }

In het lichaam van de functie is het heel duidelijk wat het argument betekent omdat het een handig en hopelijk zinvolle, naam heeft. Maar de oproepsites zien eruit als

foo(TRUE);
foo(FALSE):

Hier is het in wezen onmogelijk om te vertellen wat de parameter bedoeld is zonder altijd te kijken naar de functie-definitie of -verklaring, en het wordt veel erger als u nog meer Booleaanse parameters toevoegt. Ik stel voor

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

of

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

In beide gevallen lijkt de oproepsite nu op

foo(OPT_ON);
foo(OPT_OFF);

Welke de lezer heeft op zijn minst een kans op begrip zonder de definitie van foote vergroten.

Antwoord 3, Autoriteit 8%

Een Boolean in C is een geheel getal: nul voor false en niet-nul voor waar.

Zie ook Boolean gegevenstype , Sectie C, C++, Objective-C, AWK .

Antwoord 4, Autoriteit 7%

Hier is de versie die ik heb gebruikt:

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

Omdat onjuist één waarde heeft, maar een logisch true zou veel waarden kunnen hebben, maar techniek gaat trouw aan om te zijn wat de compiler voor het tegenovergestelde van false zal gebruiken.

Dit zorgt voor het probleem van iemand die iets is dat hierop zou komen:

if (true == !false)

Ik denk dat we het er allemaal mee eens zijn dat dat geen goede praktijk is, maar voor de ene keer kosten van het doen van “True =! False”, elimineren we dat probleem.

[bewerken] Uiteindelijk gebruikte ik:

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

Om een ​​naambotsing te voorkomen met andere regelingen die trueen false. Maar het concept blijft hetzelfde.

[bewerken] om conversie van integer naar Boolean te tonen:

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

De eerste (meest rechtse) ! converteert het gehele getal dat niet nul is naar een 0, dan de tweede (meest linkse) ! converteert de 0 naar een myfalsewaarde. Ik laat het als een oefening voor de lezer om een geheel getal nul om te zetten.

[BEWERKEN]
Het is mijn stijl om de expliciete instelling van een waarde in een opsomming te gebruiken wanneer de specifieke waarde vereist is, zelfs als de standaardwaarde hetzelfde zou zijn. Voorbeeld: Omdat false nul moet zijn, gebruik ik false = 0,in plaats van false,

Antwoord 5, autoriteit 4%

Als u een C99-compiler gebruikt, heeft deze ingebouwde ondersteuning voor bool-typen:

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

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

Antwoord 6, autoriteit 3%

Eerst eerst. C, d.w.z. ISO/IEC 9899 heeft al 19 jaareen boolean-type. Dat is veel langer dan de verwachtelengte van de C-programmeercarrière met amateur-/academische/professionele onderdelen gecombineerd bij het bezoeken van deze vraag. De mijne overtreft dat met slechts 1-2 jaar. Het betekent dat gedurende de tijd dat een gemiddelde lezer ook maar iets over C heeft geleerd, C eigenlijk het booleaanse gegevenstype heeft gehad.

Voor het datatype #include <stdbool.h>, en gebruik true, falseen bool. Of voeg het niet toe en gebruik in plaats daarvan _Bool, 1en 0.

Er worden verschillende gevaarlijkepraktijken gepromoot in de andere antwoorden op deze thread. Ik zal ze aanspreken:

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

Dit is nee-nee, omdat een toevallige lezer – die C in die 19 jaar heeft geleerd – zou verwachten dat boolverwijst naar de feitelijkeboolgegevenstype en zou zich op dezelfde manier gedragen, maar dat doet het niet! Bijvoorbeeld

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

Met C99 bool/ _Bool, zou bworden ingesteld op falseiffawas nul, en anders true. C11 6.3.1.2p1

1. Als een scalaire waarde wordt geconverteerd naar _Bool, is het resultaat 0 als de waarde gelijk is aan 0; anders is het resultaat 1. 59)

Voetnoten

59) NaN’s zijn niet gelijk aan 0 en worden dus omgezet in 1.

Met de typedefop zijn plaats, zou de doubleworden gedwongen tot een int– als de waarde van de double niet in de bereik voor int, het gedrag is niet gedefinieerd.

Natuurlijk geldt hetzelfde als trueen falsezijn gedeclareerd in een enum.

Wat nog gevaarlijkeris, is verklaren

typedef enum bool {
    false, true
} bool;

omdat nu alle waardenbehalve 1 en 0 ongeldig zijn, en als een dergelijke waarde zou worden toegewezen aan een variabele van dat type, het gedrag zou volledig ongedefinieerd zijn.

Daarom iffkun je C99 om een onverklaarbare reden niet gebruiken, voor booleaanse variabelen moet je het volgende gebruiken:

• typ inten waarden 0en 1as-is; en voer zorgvuldig domeinconversies uit van andere waarden naar deze met dubbele ontkenning !!
• of als je aandringtdat je niet meer weet dat 0 vals is en niet gelijk is aan nul, gebruik dan in ieder geval hoofdletterszodat ze niet verward worden met de C99-concepten: bool, trueen false!

Antwoord 7

typedef enum {
    false = 0,
    true
} t_bool;

Antwoord 8

C heeft een boolean type: bool(tenminste voor de laatste 10(!) jaar)

Inclusief stdbool.h en true/false werkt zoals verwacht.

Antwoord 9

Alles wat niet nul is, wordt geëvalueerd als waar in booleaanse bewerkingen, dus u kunt gewoon

#define TRUE 1
#define FALSE 0

en gebruik de constanten.

Antwoord 10

Gewoon een aanvulling op andere antwoorden en enige verduidelijking, als u C99 mag gebruiken.

+-------+----------------+-------------------------+--------------------+
|  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   |
+-------+----------------+-------------------------+--------------------+

Enkele van mijn voorkeuren:

• _Boolof bool? Beide zijn prima, maar boolziet er beter uit dan het zoekwoord _Bool.
• Geaccepteerde waarden voor boolen _Boolzijn: falseof true. Het toewijzen van 0of 1in plaats van falseof trueis geldig, maar is moeilijker te lezen en te begrijpen van de logische stroom .

Enkele informatie uit de standaard:

• _Boolis NIET unsigned int, maar maakt deel uit van de groep unsigned integer types. Het is groot genoeg om de waarden 0of 1te bevatten.
• NIET DOEN, maar ja, je kunt booltrueen falseopnieuw definiëren, maar het is zeker geen goed idee. Deze mogelijkheid wordt als verouderd beschouwd en zal in de toekomst worden verwijderd.
• Een scalair type(rekenkundige typen en aanwijzertypes) toewijzen aan _Boolof bool, als de scalarwaarde is gelijk aan 0of is vergelijkbaar met 0het zal 0zijn, anders is het resultaat 1: _Bool x = 9;9wordt geconverteerd naar 1wanneer toegewezen aan x.
• _Boolis 1 byte (8 bits), meestal komt de programmeur in de verleiding om de andere bits te gebruiken, maar dit wordt niet aanbevolen, omdat de enige garantie die wordt gegeven is dat er maar één bit is gebruik om gegevens op te slaan, niet zoals type chardat 8 bits beschikbaar heeft.

Antwoord 11

Tegenwoordig ondersteunt C99booleaanse typen, maar je moet #include <stdbool.h>.

Voorbeeld:

#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; 
} 

Uitvoer:

0
1

Antwoord 12

Het is dit:

#define TRUE 1
#define FALSE 0

Antwoord 13

Je kunt er een char of een andere container met een klein getal voor gebruiken.

Pseudo-code

#define TRUE  1
#define FALSE 0
char bValue = TRUE;

Antwoord 14

Je zou _Bool kunnen gebruiken, maar de geretourneerde waarde moet een geheel getal zijn (1 voor waar, 0 voor onwaar).
Het wordt echter aanbevolen om bool op te nemen en te gebruiken zoals in C++, zoals gezegd in
dit antwoordvan daniweb forum, evenals dit antwoord, van deze andere stackoverflow-vraag:

_bool: C99’s Boolean-type. Het gebruik van _Bool rechtstreeks wordt aanbevolen als u Legacy-code behoudt die al macros voor BOOL, TRUE of FALSE definieert. Anders zijn die macro’s gestandaardiseerd in de kop. Voeg die kop toe en je kunt Bool gebruiken, net zoals jij in C++.

Antwoord 15

Voorwaardelijke uitdrukkingen worden geacht waar te zijn als ze niet-nul zijn, maar de C-standaard vereist dat logische operatoren zelf 0 of 1 terugkeren.

@tom: #define true! false is slecht en is volledig zinloos. Als het koptekstbestand zijn weg doet naar de gecompileerde C++ -code, kan het leiden tot problemen:

void foo(bool flag);
...
int flag = TRUE;
foo(flag);

Sommige compilers genereren een waarschuwing over de INT = & GT; Bool-conversie. Soms vermijden mensen dit door:

foo(flag == TRUE);

Om de uitdrukking te dwingen een C++ BOOL te zijn. Maar als je #define true! FALSE, je eindigt met:

foo(flag == !0);

die uiteindelijk een int-to-boolvergelijking doet die de waarschuwing toch kan veroorzaken.

Antwoord 16

Als u C99 gebruikt, kunt u de _Booltype gebruiken. NEE #includeS zijn noodzakelijk. Je moet het wel als een geheel getal behandelen, waar het 1trueen 0is false.

U kunt dan TRUEen FALSEdefiniëren.

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

Antwoord 17

Dit is wat ik gebruik:

enum {false, true};
typedef _Bool bool;

_Boolis een ingebouwd type in C. Het is bedoeld voor booleaanse waarden.

Antwoord 18

U kunt de instructie #defineeenvoudig als volgt gebruiken:

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

En gebruik als volgt:

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

en ga zo maar door