En C y en algunos idiomas similares, la comparación de expresiones booleanas para la igualdad con false
o true
es un hábito peligroso.
En C, cualquier expresión escalar (numérica o puntero) se puede usar en un contexto booleano, por ejemplo, como la condición de una declaración if
. La regla de C es que if (cond)
es equivalente a if (cond != 0)
; es decir, cero es falso, y cualquier el valor distinto de cero es verdadero. Si cond
es de tipo puntero, 0
se trata como una constante de puntero nula; if (ptr)
significa if (ptr != NULL)
.
Esto significa que
if (cond)
y
if (cond == true)
no significa lo mismo . El primero es verdadero si cond
no es cero; el segundo es verdadero solo si es igual a true
, que en C (si tienes #include <stdbool.h>
) es simplemente 1
.
Por ejemplo, la función isdigit()
declarada en <ctype.h>
devuelve un valor int
, 0
si el argumento es un dígito, no es cero si no lo es. Puede devolver 42
para indicar que la condición es verdadera. La comparación de 42 == true
fallará.
Sucede que 0
es el único valor que se considera falso, por lo que la comparación de la igualdad con false
funcionará; if (!cond)
y if (cond == false)
hacen lo mismo. Pero si vas a aprovechar eso, debes recordar que compararlo con false
está bien, y compararlo con true
no. Peor aún, comparando con true
funcionará la mayor parte del tiempo (por ejemplo, la igualdad y los operadores relacionales siempre producen 0
o 1
). Esto significa que cualquier error que introduzcas al usar esto podría ser difícil de rastrear. (No se preocupe, aparecerán en cuanto muestre el código a un cliente importante).
C ++ tiene reglas ligeramente diferentes; por ejemplo, su tipo bool
está un poco más integrado en el idioma, y if (cond)
convierte cond
al tipo bool
. Pero el efecto es (en su mayoría) el mismo.
Algunos otros idiomas tienen lo que podríamos llamar booleanos con mejor comportamiento, de modo que cond == true
y cond == false
(o cualquiera que sea la sintaxis) es seguro. Aun así, todos los idiomas que he visto tienen un operador not
o !
; está ahí, así que también podrías usarlo. Usar cond == false
en lugar de !cond
o not cond
no, en mi opinión, mejora la legibilidad. (Es cierto que el carácter !
puede ser difícil de ver de un vistazo; a veces agrego un espacio después de !
para evitar esto).
Y a menudo puede evitar el problema y mejorar la claridad reorganizando el código ligeramente. Por ejemplo, en lugar de:
if (!cond) {
do_this();
}
else {
do_that();
}
puedes escribir:
if (cond) {
do_that();
}
else {
do_this();
}
Eso no siempre es mejor, pero no hace daño buscar oportunidades donde están.
Resumen: En C y C ++, las comparaciones de igualdad con true
y false
son peligrosas, demasiado verbosas y de estilo deficiente. En muchos otros idiomas, estas comparaciones pueden no ser peligrosas, pero aún son demasiado verbosas y tienen un estilo pobre.