0 es false porque ambos son cero elementos en semirrings comunes. Aunque son tipos de datos distintos, tiene sentido intuitivo convertir entre ellos porque pertenecen a estructuras algebraicas isomorfas.

• 0 es la identidad para la suma y el cero para la multiplicación. Esto es cierto para números enteros y racionales, pero no números de punto flotante IEEE-754: 0.0 * NaN = NaN y 0.0 * Infinity = NaN .

• false es la identidad para booleano xor (⊻) y cero para booleano y (∧). Si los valores booleanos se representan como {0, 1}, el conjunto de números enteros módulo 2, puede pensar en ⊻ como una suma sin acarreo y en ∧ como una multiplicación.

• "" y [] son identidades para la concatenación, pero hay varias operaciones para las que tienen sentido como cero. La repetición es una, pero la repetición y la concatenación no se distribuyen, por lo que estas operaciones no forman un semiring.

Tales conversiones implícitas son útiles en programas pequeños, pero en grandes puede hacer que los programas sean más difíciles de razonar. Solo una de las muchas compensaciones en el diseño de lenguajes.

Comentarios

• Es bueno que hayas mencionado listas. (Por cierto, nil es tanto la lista vacía [] como el valor false en Common Lisp ¿Existe una tendencia a fusionar identidades de diferentes tipos de datos?) Aún tiene que explicar por qué es natural considerar falso como una identidad aditiva y verdadero como una identidad multiplicativa y no al revés. ¿Es ‘ t posible considerar true como la identificación de AND y cero para OR?
• +1 para hacer referencia a identidades similares. Finalmente, una respuesta que no ‘ t simplemente se reduzca a la » convención, trata con ella «.
• +1 para dar detalles de una matemática concreta y muy antigua en la que esto se ha seguido y tiene sentido durante mucho tiempo
• Esta respuesta no ‘ t tiene sentido. true también es la identidad y el cero de semirings (booleanos y / o). No hay ninguna razón, aparte de la convención, para considerar que false está más cerca de 0 que true.
• @TonioElGringo: La diferencia entre verdadero y falso es la diferencia entre XOR y XNOR. Se pueden formar anillos isomorfos usando AND / XOR, donde verdadero es la identidad multiplicativa y falso el aditivo, o con OR y XNOR, donde falso es la identidad multiplicativa y verdadero es el aditivo, pero XNOR no se suele considerar como un común. operación fundamental como lo es XOR.

Porque las matemáticas funcionan.

FALSE OR TRUE is TRUE, because 0 | 1 is 1. ... insert many other examples here. 

Tradicionalmente, los programas C tienen condiciones como

 if (someFunctionReturningANumber())  

en lugar de

 if (someFunctionReturningANumber() != 0)  

porque el concepto de que cero es equivalente a falso es bien entendido.

Comentarios

• Los lenguajes están diseñados así porque las matemáticas tienen sentido. Eso fue primero.
• @Morwenn, se remonta al siglo XIX y George Boole. La gente ha estado representando False como 0 y True como! 0 durante más tiempo que las computadoras.
• No ‘ no veo por qué las matemáticas no ‘ No funciona al revés si simplemente cambia todas las definiciones para que AND sea + y OR sea *.
• Exactamente: las matemáticas funcionan en ambos sentidos y la respuesta a esta pregunta parece ser puramente convencional.
• @Robert Sería ‘ genial si pudiera deletrear el » fundamentos matemáticos » en su publicación.

Como han dicho otros, las matemáticas fueron lo primero. Por eso, 0 es false y 1 es true.

¿De qué matemáticas estamos hablando? Álgebras booleanas que datan de mediados del siglo XIX, mucho antes de que aparecieran las computadoras digitales.

También se podría decir que la convención surgió de la lógica proposicional , que es incluso más antigua que las álgebras booleanas. Esta es la formalización de muchos de los resultados lógicos que los programadores conocen y aman (false || x es igual a x, true && x es igual a x y así sucesivamente).

Básicamente, estamos hablando de aritmética en un conjunto con dos elementos. Piense en contar en binario. Las álgebras booleanas son el origen de este concepto y su base teórica. Las convenciones de lenguajes como C son solo una aplicación sencilla.

Comentarios

• Podrías , seguro. Pero mantenerlo en la forma » estándar » encaja bien con la aritmética general (0 + 1 = 1, no 0 + 1 = 0).
• Sí, pero presumiblemente escribiría AND con + y OR con * si también invirtiera las definiciones.
• Las matemáticas no ‘ t viene primero. Las matemáticas reconocieron que 0 y 1 forman un campo, en el que Y es como multiplicación y OR es como suma.
• @ Kaz: Pero {0, 1} con OR y AND no forman un campo.
• Me molesta un poco que más respuestas y comentarios digan que true = 1. Eso ‘ no es del todo exacto, porque true != 0 que no es exactamente lo mismo. Una razón (no la única) por la que se deben evitar comparaciones como if(something == true) { ... }.

Como se explica en este artículo , los valores false y true no deben confundirse con los enteros 0 y 1, pero pueden identificarse con los elementos del campo de Galois (campo finito) de dos elementos (ver aquí ).

Un campo es un conjunto con dos operaciones que satisfacen ciertos axiomas.

Los símbolos 0 y 1 se usan convencionalmente para denotar las identidades aditivas y multiplicativas de un campo porque los números reales también son un campo (pero no finito) cuyas identidades son los números 0 y 1.

La identidad aditiva es el elemento 0 del campo, de modo que para todo x:

x + 0 = 0 + x = x 

y la identidad multiplicativa es el elemento 1 del campo, de modo que para todo x:

x * 1 = 1 * x = x 

El campo finito de dos elementos tiene solo estos dos elementos, a saber, el identidad aditiva 0 (o false) y la identidad multiplicativa 1 (o true). Las dos operaciones de este campo son el XOR lógico (+) y el Y lógico (*).

Nota. Si invierte las operaciones (XOR es la multiplicación y Y es la suma) entonces la multiplicación no es distributiva sobre la suma y ya no tiene un campo. En tal caso, no tiene ninguna razón para llamar a los dos elementos 0 y 1 (en cualquier orden). Tenga en cuenta también que no puede elegir la operación O en lugar de XOR: no importa cómo interprete O / Y como suma / multiplicación, la estructura resultante no es un campo (no todos los elementos inversos existen como lo requieren los axiomas del campo).

Con respecto a las funciones C:

• Muchas funciones devuelven un número entero que es un código de error. 0 significa SIN ERROR.
• Intuitivamente, la función strcmp calcula la diferencia entre dos cadenas. 0 significa que no hay diferencia entre dos cadenas, es decir, que dos cadenas son iguales.

Las explicaciones intuitivas anteriores pueden ayudar a recordar la interpretación de los valores devueltos, pero es aún más fácil solo revisa la documentación de la biblioteca.

Comentarios

• +1 para mostrar que si los intercambias arbitrariamente, las matemáticas ya no funcionan.
• Volteado: Dado un campo con dos elementos y operaciones * y +, identificamos Verdadero con 0 y Falso con 1. Identificamos OR con * y XOR con +.
• Encontrará que ambos de estas identificaciones se realizan sobre el mismo campo y ambas son consistentes con las reglas de la lógica booleana. Desafortunadamente, su nota es incorrecta 🙂
• Si asume que True = 0, y XOR es +, entonces True debe ser la identidad de XOR. Pero no es porque True XOR True = False. A menos que redefina la operación XOR en True para que True XOR True = True. Entonces, por supuesto, su construcción funciona porque acaba de cambiar el nombre de las cosas (en cualquier estructura matemática siempre puede hacer una permutación de nombre y obtener una estructura isomórfica). Por otro lado, si deja que Verdadero, Falso y XOR tengan su significado habitual, entonces Verdadero XOR Verdadero = Falso y Verdadero no pueden ser la identidad aditiva, es decir, Verdadero no puede ser 0.
• @Giorgio: Corregí mi construcción según su comentario en mi último comentario …

Debe tener en cuenta que los sistemas alternativos también pueden ser decisiones de diseño aceptables.

Shells: el estado de salida 0 es verdadero, distinto de cero es falso

El ejemplo de shells que tratan un 0 El estado de salida como verdadero ya se ha mencionado.

 $ ( exit 0 ) && echo "0 is true" || echo "0 is false" 0 is true $ ( exit 1 ) && echo "1 is true" || echo "1 is false" 1 is false  

La razón es que hay una forma de tener éxito, pero muchas formas de fallar, por lo que usar 0 como valor especial que significa «sin errores» es pragmático.

Ruby: 0 es como cualquier otro número

Entre los lenguajes de programación «normales», hay algunos valores atípicos, como Ruby, que tratan 0 como un valor verdadero.

$ irb irb(main):001:0> 0 ? "0 is true" : "0 is false" => "0 is true" 

El el fundamento es que solo false y nil deben ser falsos. Para muchos principiantes de Ruby, es un problema. Sin embargo, en algunos casos, es bueno que el 0 se trate como cualquier otro número.

irb(main):002:0> (pos = "axe" =~ /x/) ? "Found x at position #{pos}" : "x not found" => "Found x at position 1" irb(main):003:0> (pos = "xyz" =~ /x/) ? "Found x at position #{pos}" : "x not found" => "Found x at position 0" irb(main):004:0> (pos = "abc" =~ /x/) ? "Found x at position #{pos}" : "x not found" => "x not found" 

Sin embargo , dicho sistema solo funciona en un lenguaje que pueda distinguir los booleanos como un tipo separado de los números. En los primeros días de la informática, los programadores que trabajaban con lenguaje ensamblador o lenguaje de máquina en bruto no tenían esos lujos. Probablemente sea natural tratar 0 como el estado «en blanco» y establecer un bit en 1 como una bandera cuando el código detecta que algo sucedió. Por extensión, la convención desarrolló que el cero se trataba como falso y los valores distintos de cero se trataban como verdaderos. Sin embargo, no tiene por qué ser así.

Java: los números no se pueden tratar como booleanos en absoluto

En Java, true y false son los únicos valores booleanos. Los números no son booleanos y ni siquiera se pueden convertir en booleanos ( Java Language Specification, Sec 4.2.2 ):

No hay conversiones entre los tipos integrales y el tipo boolean .

Esa regla simplemente evita la pregunta por completo: todas las expresiones booleanas deben escribirse explícitamente en el código.

Comentarios

• Rebol y Red tratan los valores INTEGER! con valor 0 como verdaderos y tienen un tipo NONE! separado (con un solo valor, NINGUNO) tratado como condicional falso además de LOGIC! false. ‘ he encontrado una frustración significativa al intentar escribir código JavaScript que trata 0 como falso; es un incr decisión comestiblemente torpe para un lenguaje escrito dinámicamente. Si quieres probar algo que puede ser nulo o 0, terminas teniendo que escribir if (thing === 0), eso no está bien.
• @HostileFork I don ‘ No lo sé. Creo que tiene sentido que 0 sea true (como cualquier otro número entero) en un lenguaje dinámico. A veces me pasaba a coger un 0 al intentar capturar None en Python, y eso a veces puede ser bastante difícil de detectar.
• Ruby no es un valor atípico. Ruby toma esto de Lisp (Ruby incluso se llama secretamente » MatzLisp «). Lisp es un lenguaje corriente en informática. Cero también es solo un valor real en el shell POSIX, porque ‘ es un fragmento de texto: if [ 0 ] ; then echo this executes ; fi. El valor de datos falsos es una cadena vacía, y una falsedad comprobable es un estado de terminación fallida de un comando, que está representado por un distinto de -zero.

Antes de abordar el caso general, podemos discutir sus contraejemplos.

Comparaciones de cadenas

En realidad, lo mismo se aplica a muchos tipos de comparaciones. Estas comparaciones calculan una distancia entre dos objetos. Cuando los objetos son iguales, la distancia es mínima. Entonces, cuando la «comparación se realiza correctamente», el valor es 0. Pero, en realidad, el valor de retorno de strcmp es no un valor booleano, es una distancia y que lo que atrapa a los programadores desprevenidos haciendo if (strcmp(...)) do_when_equal() else do_when_not_equal().

En C ++ podríamos rediseñar strcmp para devolver un Distance objeto, que anula operator bool() para devolver verdadero cuando 0 (pero luego sería mordido por un conjunto diferente de problemas). O en C simple, simplemente tenga una función streq que devuelva 1 cuando las cadenas son iguales y 0 en caso contrario.

Llamadas a la API / código de salida del programa

Aquí le interesa la razón por la que algo salió mal, porque esto provocará que las decisiones se vuelvan erróneas. Cuando las cosas tienen éxito, no desea saber nada en particular, su intención se realiza. Por lo tanto, el valor de retorno debe transmitir esta información. no es un booleano, es un código de error. El valor de error especial 0 significa «sin error». El resto del rango representa errores localmente significativos con los que tiene que lidiar (incluido 1, que a menudo significa «error no especificado»).

Caso general

Esto nos deja con la pregunta: ¿por qué los valores booleanos son True y False comúnmente representado con 1 y 0, respectivamente?

Bueno, además del argumento subjetivo «se siente mejor de esta manera», aquí hay algunas razones (subjetivas también) que puedo pensar:

• analogía del circuito eléctrico. La corriente está activada durante 1 s y desactivada durante 0 s. Me gusta tener (1, Sí, Verdadero, Activado) juntos y (0, No, Falso, Desactivado), en lugar de otra combinación

• inicializaciones de memoria. Cuando memset(0) un montón de variables (ya sean ints, floats, bools) quiero que su valor coincida con las suposiciones más conservadoras. P.ej. mi suma es inicialmente 0, el predicado es Falso, etc.

Quizás todas estas razones estén ligadas a mi educación, si me hubieran enseñado a asociar 0 con Verdadero de la Al principio, iría al revés.

Comentarios

• En realidad, hay al menos un lenguaje de programación que trata el 0 como verdadero. El shell de Unix.
• +1 para abordar el problema real: La mayor parte de la ‘ pregunta de Morwenn no es ‘ t sobre bool en absoluto.
• @ dan04 Lo es. Toda la publicación trata sobre el fundamento de la elección del elenco de int a bool en muchos lenguajes de programación. Las cosas de comparación y gestión de errores son solo ejemplos de lugares en los que lanzarlo de una manera diferente a la que ‘ está haciendo actualmente tendría sentido.

Desde una perspectiva de alto nivel, estás hablando de tres tipos de datos bastante diferentes:

1. Un booleano. La convención matemática en álgebra booleana es usar 0 para false y 1 para true, por lo que tiene sentido seguir esa convención. Creo que de esta manera también tiene más sentido intuitivamente.

2. El resultado de la comparación. Esto tiene tres valores: <, = y > (observe que ninguno de ellos es true). Para ellos tiene sentido usar los valores de -1, 0 y 1, respectivamente (o, más generalmente, un valor negativo, cero y un valor positivo).

   Si desea verificar la igualdad, Si solo tiene una función que realiza una comparación general, creo que debería hacerlo explícito usando algo como strcmp(str1, str2) == 0. Me parece confuso el uso de ! en esta situación, porque trata un valor no booleano como si fuera un booleano.

   Además, tenga en cuenta que la comparación y la igualdad no tiene que ser lo mismo. Por ejemplo, si ordena a las personas por su fecha de nacimiento, Compare(me, myTwin) debe devolver 0 , pero Equals(me, myTwin) debería devolver false.

3. El éxito o el fracaso de una función , posiblemente también con detalles sobre el éxito o el fracaso. Si está hablando de Windows, este tipo se llama HRESULT y un valor distinto de cero no necesariamente indica un error. De hecho, un valor negativo indica un error y un éxito no negativo. El valor de éxito suele ser S_OK = 0, pero también puede ser, por ejemplo, S_FALSE = 1, u otros valores.

La confusión proviene del hecho que tres lógicamente tipos de datos bastante diferentes se representan en realidad como un solo tipo de datos (un número entero) en C y algunos otros lenguajes y que puede usar un número entero en una condición. Pero no creo que tenga sentido redefinir booleanos para simplificar el uso de algunos tipos no booleanos en condiciones.

Además, considere otro tipo que se usa a menudo en una condición en C: un puntero . Allí, es natural tratar un NULL -punta (que se representa como 0) como false. Por lo tanto, seguir tu sugerencia también dificultaría más el trabajo con punteros (aunque, personalmente, prefiero comparar explícitamente punteros con NULL, en lugar de tratarlos como booleanos).

Cero puede ser falso porque la mayoría de las CPU tienen un indicador CERO que se puede usar para bifurcar. Guarda una operación de comparación.

Veamos por qué.

Algunos psuedocode, ya que la audiencia probablemente no lee el ensamblaje

c- source simple loop llama a wibble 10 veces

 for (int foo =10; foo>0; foo-- ) /* down count loop is shorter */ { wibble(); }  

algunos pretenden ensamblar para eso

0x1000 ld a 0x0a "foo=10 0x1002 call 0x1234 "call wibble() 0x1005 dec a "foo-- 0x1006 jrnz -0x06 "jump back to 0x1000 if not zero 0x1008 

c- fuente otro simple bucle llama a wibble 10 veces

 for (int foo =0; foo<10; foo-- ) /* up count loop is longer */ { wibble(); }  

algo de montaje simulado para este caso

0x1000 ld a 0x00 "foo=0 0x1002 call 0x1234 "call wibble() 0x1005 dec a "foo-- 0x1006 cmp 0x0a "compare foo to 10 ( like a subtract but we throw the result away) 0x1008 jrns -0x08 "jump back to 0x1000 if compare was negative 0x100a 

más fuente de c

 int foo=10; if ( foo ) wibble()  

y el ensamblaje

0x1000 ld a 0x10 0x1002 jz 0x3 0x1004 call 0x1234 0x1007 

¿Ves lo corto que es?

algo más de fuente c

 int foo=10; if ( foo==0 ) wibble()  

y el ensamblaje (supongamos un compilador marginalmente inteligente que puede reemplazar == 0 sin comparar )

0x1000 ld a 0x10 0x1002 jz 0x3 0x1004 call 0x1234 0x1007 

Ahora intentemos una convención de true = 1

c fuente más #define TRUE 1 int foo = TRUE; if (foo == VERDADERO) wibble ()

y el ensamblaje

0x1000 ld a 0x1 0x1002 cmp a 0x01 0x1004 jz 0x3 0x1006 call 0x1234 0x1009 

¿Ves qué tan corto es el caso con true distinto de cero?

Realmente Las primeras CPU tenían pequeños conjuntos de indicadores adjuntos al acumulador.

Para verificar si a> bo a = b generalmente toma una instrucción de comparación.

• A menos que B sea ya sea CERO – en cuyo caso la bandera CERO se establece Implementado como un NOR lógico simple o todos los bits en el Acumulador.
• O NEGATIVO en el cual simplemente use el «bit de signo», es decir, el bit más significativo del Acumulador si está utilizando aritmética en complemento a dos. (Principalmente lo hacemos)

Vamos a reafirmar esto. En algunas CPU más antiguas, no tenía que usar una instrucción de comparación para un acumulador igual a CERO o un acumulador menor que cero.

¿Ahora ve por qué el cero podría ser falso?

Tenga en cuenta que este es un código psuedo y ningún conjunto de instrucciones real se parece a esto. Si conoce el ensamblaje, sabe que estoy simplificando mucho las cosas aquí. Si sabe algo sobre diseño de compiladores, no necesita leer esta respuesta. Cualquiera que sepa algo sobre desenrollado de bucles o predicción de ramas, la clase avanzada está al final del pasillo en la habitación 203.

Comentarios

• Su punto no está bien expresado aquí porque, en primer lugar, if (foo) y if (foo != 0) debería generar el mismo código y, en segundo lugar, ‘ estás mostrando que el lenguaje ensamblador que ‘ estás usando de hecho tiene operandos booleanos y pruebas para ellos. Por ejemplo, jz significa jump if zero. En otras palabras, if (a == 0) goto target; . Y la cantidad ni siquiera se está probando directamente; la condición se convierte en una bandera booleana que se almacena en una palabra de máquina especial. Es ‘ en realidad más como cpu.flags.zero = (a == 0); if (cpu.flags.zero) goto target;
• No Kaz, la CPU anterior ‘ s no funcionaba así. T El jz / jnz se puede ejecutar sin hacer una instrucción de comparación. Ese fue el punto de toda mi publicación.
• No ‘ no escribí nada sobre una instrucción de comparación.
• ¿Puedes citar un procesador que tiene una instrucción jz pero no jnz? (o cualquier otro conjunto asimétrico de instrucciones condicionales)

Hay muchas respuestas que sugieren que la correspondencia entre 1 y verdadero es necesaria por alguna propiedad matemática. No puedo encontrar ninguna propiedad de este tipo y sugerir que es una convención puramente histórica.

Dado un campo con dos elementos, tenemos dos operaciones: suma y multiplicación. Podemos mapear operaciones booleanas en este campo de dos maneras :

Tradicionalmente, identificamos Verdadero con 1 y Falso con 0. Identificamos Y con * y XOR con +. Por lo tanto, OR es una adición saturante.

Sin embargo, podríamos con la misma facilidad identificamos Verdadero con 0 y Falso con 1. Luego identificamos OR con * y XNOR con +. Por lo tanto, Y es una adición saturante.

Comentarios

• Si si hubiera seguido el enlace en wikipedia, podría haber encontrado que el concepto de álgebra booleana está relacionado con el de un campo de Galois de dos elementos ( en.wikipedia.org/wiki / GF% 282% 29 ). Los símbolos 0 y 1 se utilizan convencionalmente para denotar las identidades aditiva y multiplicativa, respectivamente, porque los números reales también son un campo cuyas identidades son los números 0 y 1.
• @NeilG Creo que Giorgio está intentando decirlo ‘ s más que una simple convención. 0 y 1 en álgebra booleana son básicamente lo mismo que 0 y 1 en GF (2), que se comportan casi igual que 0 y 1 en números reales con respecto a la suma y la multiplicación.
• @svick: No , porque simplemente puede cambiar el nombre de la multiplicación y la adición de saturación para que sean O y Y y luego voltear las etiquetas para que 0 sea Verdadero y 1 sea Falso.Giorgio está diciendo que era una convención de lógica booleana, que fue adoptada como una convención de la informática.
• @Neil G: No, no se puede cambiar + y * y 0 y 1 porque un campo requiere distributividad de multiplicación sobre suma (consulte en.wikipedia.org/wiki/Field_%28mathematics%29 ), pero si establece +: = AND y *: = XOR , obtienes T XOR (T AND F) = T XOR F = T, mientras que (T XOR T) AND (T XOR F) = F AND T = F. Por lo tanto, al cambiar las operaciones y las identidades no tienes un campo nunca más. Entonces, en mi opinión, definir 0 y 1 como las identidades de un campo apropiado parece capturar lo falso y lo verdadero con bastante fidelidad.
• @giorgio: He editado la respuesta para que sea obvio lo que está sucediendo.

Curiosamente, el cero no siempre es falso.

En particular, la convención de Unix y Posix es definir EXIT_SUCCESS como 0 (y EXIT_FAILURE como 1). En realidad, es incluso una convención C estándar.

Así que para los shells Posix y salir (2) syscalls, 0 significa «exitoso», que intuitivamente es más verdadero que falso.

En particular, el shell «s if quiere un el proceso devuelve EXIT_SUCCESS (que es 0) para seguir su rama «luego»!

En Scheme (pero no en Common Lisp o en MELT ) 0 y nil (es decir, () en Scheme) son verdaderas, ya que el único valor falso es #f

^{¡Estoy de acuerdo, soy quisquilloso!}

C se utiliza para la programación de bajo nivel cerca del hardware, un área en la que a veces es necesario cambiar entre operaciones lógicas y bit a bit, en los mismos datos. Ser necesario convertir una expresión numérica a booleana solo para realizar una prueba sería desordenado el código.

Puede escribir cosas como:

 if (modemctrl & MCTRL_CD) { /* carrier detect is on */ }  

en lugar de

 if ((modemctrl & MCTRL_CD) != 0) { /* carrier detect is on */ }  

En un ejemplo aislado no es tan malo, pero tener que hacer eso se volverá molesto.

Del mismo modo, las operaciones inversas. Es útil para el resultado de una operación booleana, como una comparación, producir un 0 o un 1: supongamos que queremos establecer el tercer bit de una palabra en función de si modemctrl tiene el bit de detección de portadora:

 flags |= ((modemctrl & MCTRL_CD) != 0) << 2;  

Aquí tenemos que tener el != 0, para reducir el resultado de la expresión & biwise a 0 o 1, pero debido a que el resultado es solo un número entero, nos ahorramos tener que agregar algunas conversiones molestas para convertir booleano en entero.

Aunque el C moderno ahora tiene un bool tipo, aún conserva la validez de código como este, tanto porque «es algo bueno, como por la rotura masiva de compatibilidad con versiones anteriores que se causaría de otra manera.

Otro ejemplo en el que C es hábil: probar dos condiciones booleanas como un interruptor de cuatro direcciones:

 switch (foo << 1 | bar) { /* foo and bar booleans are 0 or 1 */ case 0: /* !foo && !bar */ break; case 1: /* !foo && bar */ break; case 2: /* foo && !bar */ break; case 3: /* foo && bar */ break; }  

¡No podrías quitarle esto al programador de C sin luchar!

Por último, C a veces sirve como una especie de lenguaje ensamblador de alto nivel. En los lenguajes ensambladores, tampoco tenemos tipos booleanos. Un valor booleano es solo un bit o un valor cero versus un valor distinto de cero en una ubicación de memoria o registro. Un cero entero, un cero booleano y la dirección cero se prueban de la misma manera en conjuntos de instrucciones en lenguaje ensamblador (y quizás incluso en coma flotante cero). La semejanza entre C y el lenguaje ensamblador es útil, por ejemplo, cuando se usa C como el lenguaje de destino para compilar otro lenguaje (¡incluso uno que tenga booleanos fuertemente tipados!)

Un valor booleano o verdadero solo tiene 2 valores. Verdadero y falso.

Estos deben no representarse como enteros, sino como bits (0 y 1 ).

Decir que cualquier otro entero además de 0 o 1 no es falso es una afirmación confusa. Las tablas de verdad tratan con valores de verdad, no con números enteros.

De un valor de verdad prospectivo, -1 o 2 rompería todas las tablas de verdad y cualquier lógica booleana asociada con ellas.

• 0 Y -1 ==?!
• 0 O 2 ==?!

La mayoría de los idiomas suelen tener un boolean tipo que cuando se envía a un tipo de número, como entero, revela falso para ser lanzado como un valor entero de 0.

Comentarios

• 0 AND -1 == cualquier valor booleano al que los envíe. De eso ‘ trata mi pregunta, por qué enviarlos a TRUE o FALSENunca dije, tal vez lo hice, pero no era mi intención, los números enteros eran verdaderos o falsos, pregunté por qué se evalúan a cualquiera cuando se convierten en booleanos.

En última instancia, estás hablando de romper el lenguaje principal porque algunas API son malas. Las API de mierda no son nuevas y no se pueden arreglar rompiendo el lenguaje. Es un hecho matemático que 0 es falso y 1 es verdadero, y cualquier lenguaje que no respete esto está fundamentalmente roto. La comparación de tres vías es nicho y no tiene por qué hacer que su resultado se convierta implícitamente a bool ya que devuelve tres resultados posibles. Las antiguas API de C simplemente tienen un manejo de errores terrible, y también están paralizadas porque C no tiene las características de lenguaje necesarias para no tener interfaces terribles.

Tenga en cuenta que no estoy diciendo eso para los lenguajes que no tienen integer-> conversión booleana.

Comentarios

• » Es un hecho matemático que 0 es falso y 1 es verdadero » Erm.
• ¿Puede citar una referencia para su » hecho matemático de que 0 es falso y 1 es verdadero «? Tu respuesta suena peligrosamente como una perorata.
• No es ‘ un hecho matemático, pero ‘ ha sido una convención matemática desde el siglo 19.
• El álgebra booleana está representada por un campo finito en el que 0 y 1 son los elementos de identidad para operaciones que se asemejan a la suma y la multiplicación. Esas operaciones son, respectivamente, OR y AND. De hecho, el álgebra booleana se escribe de manera muy similar al álgebra normal, donde la yuxtaposición denota Y, y el símbolo + denota OR. Entonces, por ejemplo, abc + a'b'c significa (a and b and c) or (a and (not b) and (not c)).