C Language
Booleano

Observaciones

Utilizando 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!");
    }
}

Usando #define

C de todas las versiones, tratará efectivamente cualquier valor entero distinto de 0 como true para los operadores de comparación y el valor entero 0 como false . Si no tiene disponible _Bool o bool partir de C99, puede simular un tipo de datos Boolean en C usando macros #define , y aún puede encontrar esas cosas en el código heredado.

#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!");
    }
}

No introduzca esto en el nuevo código ya que la definición de estas macros podría chocar con los usos modernos de <stdbool.h> .

Usando el tipo intrínseco (incorporado) _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;

Enteros y punteros en expresiones booleanas.

Todos los enteros o punteros se pueden usar en una expresión que se interpreta como "valor de verdad".

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");
  }
...

La expresión argc % 4 se evalúa y conduce a uno de los valores 0 , 1 , 2 o 3 . El primero, 0 es el único valor que es "falso" y lleva la ejecución a la parte else . Todos los demás valores son "verdaderos" y entran en la parte if .

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

Aquí se evalúa el puntero A y, si es un puntero nulo, se detecta un error y el programa sale.

Muchas personas prefieren escribir algo como A == NULL , en cambio, pero si tiene comparaciones de punteros como parte de otras expresiones complicadas, las cosas se vuelven difíciles de leer rápidamente.

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]);
}

Para verificar esto, tendría que escanear un código complicado en la expresión y estar seguro de las preferencias del operador.

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]);
}

es relativamente fácil de capturar: si el puntero es válido, verificamos si el primer carácter es distinto de cero y luego verificamos si es una letra.

Definiendo un tipo bool usando typedef

Teniendo en cuenta que la mayoría de los depuradores no conocen las macros de #define , pero pueden verificar las constantes de enum , puede ser conveniente hacer algo como esto:

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

Esto permite que los compiladores funcionen con versiones históricas de C, pero sigue siendo compatible con versiones posteriores si el código se compila con un compilador de C moderno.

Para obtener más información sobre typedef , consulte Typedef , para obtener más información sobre enum consulte Enumeraciones