C Language
Boolean

Anmärkningar

Använda stdbool.h

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

int main(void) {
    bool x = true;  /* equivalent to bool x = 1; */
    bool y = false; /* equivalent to bool y = 0; */
    if (x)  /* Functionally equivalent to if (x != 0) or if (x != false) */
    {
        puts("This will print!");
    }
    if (!y) /* Functionally equivalent to if (y == 0) or if (y == false) */
    {
        puts("This will also print!");
    }
}

Med #define

C av alla versioner, kommer effektivt att behandla alla heltal utanför 0 som true för jämförelseoperatörer och heltalvärdet 0 som false . Om du inte har _Bool eller bool från och med C99 tillgängliga, kan du simulera en boolesisk datatyp i C med #define makron och du kan fortfarande hitta sådana saker i äldre kod.

#include <stdio.h>

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

int main(void) {
    bool x = true;  /* Equivalent to int x = 1; */
    bool y = false; /* Equivalent to int y = 0; */
    if (x) /* Functionally equivalent to if (x != 0) or if (x != false) */
    {
        puts("This will print!");
    }
    if (!y) /* Functionally equivalent to if (y == 0) or if (y == false) */
    {
        puts("This will also print!");
    }
}

Inför inte detta i ny kod eftersom definitionen av dessa makron kan kollidera med modern användning av <stdbool.h> .

Använda den inneboende (inbyggda) typen _Bool

#include <stdio.h>

int main(void) {
    _Bool x = 1; 
    _Bool y = 0;
    if(x) /* Equivalent to if (x == 1) */
    {
        puts("This will print!");
    }
    if (!y) /* Equivalent to if (y == 0) */
    {
        puts("This will also print!");
    }
}

_Bool z = X;

Heltal och pekare i Booleska uttryck.

Alla heltal eller pekare kan användas i ett uttryck som tolkas som "sanningsvärde".

int main(int argc, char* argv[]) {
  if (argc % 4) {
    puts("arguments number is not divisible by 4");
  } else {
    puts("argument number is divisible by 4");
  }
...

Uttrycket argc % 4 utvärderas och leder till ett av värdena 0 , 1 , 2 eller 3 . Den första, 0 är det enda värdet som är "falskt" och leder exekvering till den else delen. Alla andra värden är "sanna" och går in i if delen.

double* A = malloc(n*sizeof *A);
if (!A) {
   perror("allocation problems");
   exit(EXIT_FAILURE);
}

Här utvärderas pekaren A och om det är en nollpekare upptäcks ett fel och programmet avslutas.

Många föredrar att skriva något som A == NULL istället, men om du har sådana pekarjämförelser som en del av andra komplicerade uttryck, blir saker snabbt svåra att läsa.

char const* s = ....;   /* some pointer that we receive */
if (s != NULL && s[0] != '\0' && isalpha(s[0])) {
   printf("this starts well, %c is alphabetic\n", s[0]);
}

För att detta ska kunna kontrolleras måste du skanna en komplicerad kod i uttrycket och vara säker på operatörens preferenser.

char const* s = ....;   /* some pointer that we receive */
if (s && s[0] && isalpha(s[0])) {
   printf("this starts well, %c is alphabetic\n", s[0]);
}

är relativt lätt att fånga: om pekaren är giltig kontrollerar vi om det första tecknet är icke-noll och kontrollerar sedan om det är en bokstav.

Definiera en booltyp med typedef

Med tanke på att de flesta felsökare inte är medvetna om #define makron, men kan kontrollera enum , kan det vara önskvärt att göra något liknande:

#if __STDC_VERSION__ < 199900L
typedef enum { false, true } bool;
/* Modern C code might expect these to be macros. */
# ifndef bool
#  define bool bool
# endif
# ifndef true
#  define true true
# endif
# ifndef false
#  define false false
# endif
#else
# include <stdbool.h>
#endif

/* Somewhere later in the code ... */
bool b = true;

Detta gör att kompilatorer för historiska versioner av C kan fungera, men förblir kompatibla framåt om koden är kompilerad med en modern C-kompilator.

För mer information om typedef , se Typedef , för mer om enum se Enumerations