Comentarios de software

Quiero protestar desde aquí contra la costumbre, bastante extendida, de comparar valores booleanos directamente con las constantes true y false.
Es decir:

if (cond == true)
    ...;

¡No tiene sentido! El resultado de comparar una expresión booleana con true es siempre la propia expresión.

El ejemplo anterior es equivalente a:

if (cond)
    ...;

Comparar un booleano con false es igual de absurdo:

if (cond == false)
    ...;
//es idéntico a
if (!cond)
    ...;

Y ni hablemos de comparar con el operador distinto-de !=.

Hay quien argumenta que la comparación es más fácil de leer o de entender. Pero eso solo ocurre si en nombre de la variable está mal escogido. Por ejemplo:

bool accion = true;
//...
if (accion)
    uno();
else
    dos();
// o 
if (accion == true)
    uno();
else
    dos();

Aquí la comparación puede ser más fácil de entender porque el nombre de la variable no significa nada, y el significado de true y false es arbitrario (se les podría dar la vuelta y sería lo mismo).
Si escribimos lo siguiente:

bool hagoUno = true;
//...
if (hagoUno)
    uno();
else
    dos();
// o 
if (hagoUno == true)
    uno();
else
    dos();

Ahora se entiende bien. Al leer la condición if (hagoUno) se entiende de forma totalmente natural.
Si no se nos ocurre un nombre con sentido para la variable, es mejor crear una enumeración:

enum Accion {UNO, DOS};
Accion accion = UNO;
//...
if (accion == UNO)
    uno();
else
    dos();
//o un switch

Sigue siendo perfectamente legible.

Otro mal hábito, relacionado, pero menos molesto es el de escribir una condición para asignar un valor booleano:

bool res;
if (cond)
    res = true;
else
    res = false;
//y en una función
bool funcion()
{
    if (cond)
        return false;
    else
        return true;
}

Más simple y elegante sería:

bool res = cond;
//y en una función
bool funcion()
{
    return !cond;
}

¡Pero el libro de estilo de mi empresa/escuela/facultad dice que se debe comparar el booleano con true o false expresamente en la condición del if!

Pues aquí tienes un problema, porque al comparar un booleano con otro el resultado es también un booleano, que tendrías que comparar con true, que daría otro booleano, que tendrías que volver a compararlo, y así hasta el infinito:

if (cond == true == true == true)
    ;

Dicho esto, existe un caso en el que tiene sentido la comparación entre booleanos… !para hacer un OR exclusivo lógico! La igualdad equivale a un NXOR y la desigualdad a un XOR:

 //una o la otra, pero no ambas: XOR
if (condA != condB)
    ;
 
//o ambas o ninguna: NXOR
if (condA != condB)
    ;

Artículos relacionados:

1. Novedades de C++98 Me he pasado varios artículos discutiendo las novedades de C++0x...
2. Resolviendo un Sudoku con Python El otro día estaba haciendo un Sudoku con lápiz y...

Filed under:
C++ por rodrigo