¿Por qué #define TRUE (1 == 1) en una macro booleana C en lugar de simplemente como 1?

He visto definiciones en C

#define TRUE (1==1)
#define FALSE (!TRUE)

¿Es esto necesario? ¿Cuál es el beneficio sobre simplemente definir VERDADERO como 1 y FALSO como 0?

Este enfoque utilizará el booleantipo real (y resolverá truey false) si el compilador lo admite. (específicamente, C ++)

Sin embargo, sería mejor verificar si C ++ está en uso (a través de la __cplusplusmacro) y realmente usar truey false.

En un compilador de C, esto es equivalente a 0y 1.
(tenga en cuenta que eliminar los paréntesis lo romperá debido al orden de las operaciones)

La respuesta es la portabilidad. Los valores numéricos de TRUEy FALSEno son importantes. Lo que es importante es que una afirmación como if (1 < 2)se evalúa en if (TRUE)y una declaración como if (1 > 2)evalúa a if (FALSE).

Por supuesto, en C, (1 < 2)evalúa 1y (1 > 2)evalúa a 0, por lo que, como han dicho otros, no hay una diferencia práctica en lo que respecta al compilador. Pero al permitir que el compilador defina TRUEy de FALSEacuerdo con sus propias reglas, está haciendo que sus significados sean explícitos para los programadores, y está garantizando la coherencia dentro de su programa y cualquier otra biblioteca (suponiendo que la otra biblioteca siga los estándares C ... estar asombrado).

Alguna historia
Algunos BASICs definidos FALSEcomo 0y TRUEcomo -1. Al igual que muchos lenguajes modernos, interpretaron cualquier valor distinto de cero como TRUE, pero evaluaron expresiones booleanas que eran verdaderas como -1. Su NOToperación se implementó agregando 1 y volteando el signo, porque era eficiente hacerlo de esa manera. Entonces se convirtió en 'NO x' -(x+1). Un efecto secundario de esto es que un valor como 5evalúa a TRUE, pero NOT 5evalúa a -6, ¡que también lo es TRUE! Encontrar este tipo de error no es divertido.

Mejores prácticas
Dadas las de facto reglas que cero se interpreta como FALSEy cualquier valor distinto de cero se interpreta como TRUE, usted debe nunca se comparen las expresiones booleanas de aspecto a TRUEoFALSE . Ejemplos:

if (thisValue == FALSE)  // Don't do this!
if (thatValue == TRUE)   // Or this!
if (otherValue != TRUE)  // Whatever you do, don't do this!

¿Por qué? Porque muchos programadores usan el atajo de tratar ints como bools. No son lo mismo, pero los compiladores generalmente lo permiten. Entonces, por ejemplo, es perfectamente legal escribir

if (strcmp(yourString, myString) == TRUE)  // Wrong!!!

Eso parece legítimo, y el compilador lo aceptará felizmente, pero probablemente no haga lo que quieras. Eso es porque el valor de retorno de strcmp()es

      0 si yourString == myString
    <0 si yourString < myString
    > 0 siyourString > myString

Entonces la línea de arriba TRUEsolo regresa cuando yourString > myString.

La forma correcta de hacer esto es

// Valid, but still treats int as bool.
if (strcmp(yourString, myString))

o

// Better: lingustically clear, compiler will optimize.
if (strcmp(yourString, myString) != 0)

Similar:

if (someBoolValue == FALSE)     // Redundant.
if (!someBoolValue)             // Better.
return (x > 0) ? TRUE : FALSE;  // You're fired.
return (x > 0);                 // Simpler, clearer, correct.
if (ptr == NULL)                // Perfect: compares pointers.
if (!ptr)                       // Sleazy, but short and valid.
if (ptr == FALSE)               // Whatisthisidonteven.

A menudo encontrará algunos de estos "malos ejemplos" en el código de producción, y muchos programadores experimentados juran por ellos: funcionan, algunos son más cortos que sus alternativas correctas (¿pedante?) Y los modismos son casi universalmente reconocidos. Pero considere: las versiones "correctas" no son menos eficientes, están garantizadas para ser portátiles, pasarán incluso las cartas más estrictas e incluso los nuevos programadores las entenderán.

¿No vale eso?

El (1 == 1)truco es útil para definir TRUEde una manera que sea transparente para C, pero que proporcione una mejor escritura en C ++. El mismo código puede interpretarse como C o C ++ si está escribiendo en un dialecto llamado "Clean C" (que se compila como C o C ++) o si está escribiendo archivos de encabezado de API que pueden ser utilizados por programadores de C o C ++.

En las unidades de traducción C, 1 == 1tiene exactamente el mismo significado que 1; y 1 == 0tiene el mismo significado que 0. Sin embargo, en las unidades de traducción de C ++, 1 == 1tiene tipo bool. Entonces la TRUEmacro definida de esa manera se integra mejor en C ++.

Un ejemplo de cómo se integra mejor es que, por ejemplo, si la función footiene sobrecargas por inty para bool, entonces foo(TRUE)elegirá la boolsobrecarga. Si TRUEsolo se define como 1, entonces no funcionará bien en C ++. foo(TRUE)querrá la intsobrecarga.

Por supuesto, C99 introdujo bool, truey falsey estos se pueden utilizar en los archivos de cabecera que trabajan con C99 y con C.

Sin embargo:

• esta práctica de definir TRUEy FALSEcomo (0==0)y (1==0)predates C99.
• Todavía hay buenas razones para mantenerse alejado de C99 y trabajar con C90.

Si está trabajando en un proyecto de C mixta y C ++, y no desea C99, definir el menor de los casos true, falsey boolen su lugar.

#ifndef __cplusplus
typedef int bool;
#define true (0==0)
#define false (!true)
#endif

Dicho esto, el 0==0truco fue (¿es?) Utilizado por algunos programadores incluso en código que nunca tuvo la intención de interactuar con C ++ de ninguna manera. Eso no compra nada y sugiere que el programador tiene un malentendido sobre cómo funcionan los booleanos en C.

En caso de que la explicación de C ++ no fuera clara, aquí hay un programa de prueba:

#include <cstdio>

void foo(bool x)
{
   std::puts("bool");  
}

void foo(int x)
{
   std::puts("int");  
}

int main()
{
   foo(1 == 1);
   foo(1);
   return 0;
}

La salida:

bool
int

En cuanto a la pregunta de los comentarios sobre cómo se sobrecargan las funciones de C ++ relevantes para la programación mixta de C y C ++. Estos solo ilustran una diferencia de tipo. Una razón válida para querer una trueconstante boolcuando se compila como C ++ es para un diagnóstico limpio. En sus niveles de advertencia más altos, un compilador de C ++ podría advertirnos sobre una conversión si pasamos un entero como boolparámetro. Una razón para escribir en Clean C no es solo que nuestro código es más portátil (ya que los compiladores de C ++ lo entienden, no solo los compiladores de C), sino que podemos beneficiarnos de las opiniones de diagnóstico de los compiladores de C ++.

#define TRUE (1==1)
#define FALSE (!TRUE)

es equivalente a

#define TRUE  1
#define FALSE 0

C ª.

El resultado de los operadores relacionales es 0o 1. 1==1está garantizado para ser evaluado 1y !(1==1)está garantizado para ser evaluado 0.

No hay absolutamente ninguna razón para usar la primera forma. Sin embargo, tenga en cuenta que la primera forma no es menos eficiente, ya que en casi todos los compiladores se evalúa una expresión constante en tiempo de compilación en lugar de en tiempo de ejecución. Esto está permitido de acuerdo con esta regla:

(C99, 6.6p2) "Se puede evaluar una expresión constante durante la traducción en lugar del tiempo de ejecución, y en consecuencia se puede usar en cualquier lugar que pueda ser una constante".

PC-Lint incluso emitirá un mensaje (506, valor booleano constante) si no utiliza un literal para TRUEy FALSEmacros:

Para C, TRUEdebe definirse como ser 1. Sin embargo, otros idiomas usan cantidades distintas de 1, por lo que algunos programadores sienten que !0está jugando de forma segura.

También en C99, las stdbool.hdefiniciones de macros booleanas truey false directamente usan literales:

#define true   1
#define false  0

Aparte de C ++ (ya mencionado), otro beneficio es para las herramientas de análisis estático. El compilador eliminará cualquier ineficiencia, pero un analizador estático puede usar sus propios tipos abstractos para distinguir entre resultados de comparación y otros tipos enteros, por lo que sabe implícitamente que VERDADERO debe ser el resultado de una comparación y no debe suponerse que es compatible. con un entero

Obviamente, C dice que son compatibles, pero puede optar por prohibir el uso deliberado de esa función para ayudar a resaltar errores, por ejemplo, dónde alguien podría haber confundido &y &&/ o haber confundido su precedencia de operador.

La diferencia práctica es ninguna. 0se evalúa falsey 1se evalúa en true. El hecho de que use una expresión booleana ( 1 == 1) o 1, para definir true, no hace ninguna diferencia. Ambos son evaluados para int.

Tenga en cuenta que la biblioteca estándar de C proporciona una cabecera específica para definir booleanos: stdbool.h.

No sabemos el valor exacto al que TRUE es igual y los compiladores pueden tener sus propias definiciones. Entonces, lo que usted privilegia es usar el interno del compilador para la definición. Esto no siempre es necesario si tiene buenos hábitos de programación, pero puede evitar problemas con algún estilo de codificación incorrecto, por ejemplo:

if ((a> b) == TRUE)

Esto podría ser un desastre si define manualmente VERDADERO como 1, mientras que el valor interno de VERDADERO es otro.

1. Elemento de la lista

Por lo general, en el lenguaje de programación C, 1 se define como verdadero y 0 se define como falso. De ahí por qué ves lo siguiente con bastante frecuencia:

#define TRUE 1 
#define FALSE 0

Sin embargo, cualquier número que no sea igual a 0 también se evaluaría como verdadero en una declaración condicional. Por lo tanto, usando lo siguiente:

#define TRUE (1==1)
#define FALSE (!TRUE)

Puede demostrar explícitamente que está tratando de ir a lo seguro haciendo falso igual a lo que no es cierto.