Booleano verdadero - positivo o negativo 1 1?

Question

Estoy diseñando un lenguaje, y tratando de decidir si true debe ser 0x01 o 0xFF. Obviamente, todos los valores distintos de cero se convertirán en verdad, pero estoy tratando de decidir sobre la representación interna exacta.

¿Cuáles son los pros y los contras de cada opción?

Answer 1

0 es falso, porque el procesador tiene una bandera que se establece cuando un registro se establece en cero.

No hay otras banderas se establecen en cualquier otro valor (0x01, 0xFF, etc.) - pero la bandera cero se establece en false cuando hay un valor distinto de cero en el registro

Así que aquí las respuestas que abogan por la definición de 0 como falso y todo lo demás como verdaderos son correctos.

Si desea "definir" un valor por defecto de verdad, entonces 0x01 es mejor que la mayoría:

• Representa el mismo número en cada longitud de bits y de signo
• Sólo se requiere una prueba de un bit si desea saber si es verdad, debería estar disponible, o costosa la bandera cero a utilizar
• No hay necesidad de preocuparse por la extensión de signo durante la conversión a otros tipos
• Las expresiones lógicas y aritméticas actúan de la misma en él

-Adán

Answer 2

No importa, con tal de que satisfaga las normas para la representación exterior.

Me gustaría tener una pizca de C aquí, donde falsa se define como absolutamente 0, y se define como verdadera, no falsa. Esta es una distinción importante, si se compara con un valor absoluto para la verdadera. A menos que tenga un tipo que sólo tiene dos estados, hay que tener en cuenta todos los valores dentro de ese tipo de valor, lo que es verdadero y lo que es falso.

Answer 3

¿Por qué estás eligiendo que los valores no nulos son verdaderas? En Ada verdadero es verdadero y lo falso es falso. No hay ningún tipo de conversión implícita hacia y desde booleanas.

Answer 4

El uso de -1 tiene una ventaja en un lenguaje de tipos débiles - si te equivocas y utilizar el operador de bits and en lugar del operador and lógica, su condición sigue siendo evaluará correctamente, siempre y cuando uno de los operandos se ha convertido en la representación booleana canónica. Esto no es cierto si la representación canónica es 1.

  0xffffffff & 0x00000010 == 0x00000010 (true)
  0xffffffff && 0x00000010 == 0xffffffff (true)

y

  0x00000001 & 0x00000010 == 0x00000000 (false)
  0x00000001 && 0x00000010 == 0xffffffff (true)

Answer 5

OMI, si desea seguir con false = 0x00, 0x01 se debe utilizar. 0xFF está generalmente:

• una señal de que alguna operación se desbordó

o

• un marcador de error

Y en ambos casos, probablemente significa false . Por lo tanto el * nix retorno valor convención de ejecutables, que true = 0x00, y cualquier valor distinto de cero es falsa.

Answer 6

-1 es más largo que escribir de 1 ...

Al final no importa ya que 0 es falso y todo lo demás es cierto, y nunca se comparará con la representación exacta de la verdadera.

Editar, para los votantes hacia abajo, explique por qué. Esta respuesta es esencialmente la misma que la que actualmente está clasificado en 19. De modo que sea 21 votos a diferencia de lo que es la misma respuesta básica.

Si es debido a la observación -1, es cierto, la persona que realmente define la "verdadera" (por ejemplo: el escritor del compilador) va a tener que utilizar -1 en lugar de 1, suponiendo que optó por utilizar una representación exacta. -1 va a tomar más tiempo para escribir que 1, y el resultado final será el mismo. La declaración es tonto, que estaba destinado a ser tonto, porque no hay ninguna diferencia real entre los dos (1 ó -1).

Si va a marcar algo por lo menos proporcionar una justificación para ello.

Answer 7

0xff es una elección extraña, ya que tiene una suposición implícita de que 8 bits es su unidad de almacenamiento mínimo. Pero no es tan raro que desee almacenar valores booleanos más compacta que eso.

Tal vez usted quiere reformular por pensar en si los operadores booleanos producen algo que es sólo un 0 o 1 bit (que funciona independientemente de la extensión de signo), o es todo-ceros o todos unos (y depende de la extensión de signo de la firma cantidades en complemento a dos para mantener todos unos en cualquier longitud).

Creo que su vida es más simple con 0 y 1.

Answer 8

Las ventajas son ninguno, y los contras hay ninguno, también. A medida que el tiempo que proporcionan una conversión automática desde un entero a boolean, será arbitraria, por lo que realmente no importa el número que elija.

Por otro lado, si usted no permitió que esta conversión automática que tendría un profesional: que no habría alguna regla totalmente arbitraria en su idioma. Usted no tendría (7 - 4 - 3) == false o 3 * 4 + 17 == "Hello" o "Hi mom!" == Complex(7, -2).

Answer 9

Creo que el método C es el camino a seguir. 0 significa falso, cualquier otra cosa significa verdad. Si vas con otra asignación de verdad, entonces lo que queda es el problema de tener valores indeterminados -. Que no son ni verdaderas ni falsas

Si se trata de un lenguaje que se le compilando un conjunto de instrucciones específico que tiene un soporte especial para una representación en particular, entonces voy a dejar que te guía. Sin embargo, en ausencia de cualquier información adicional, por una representación interna 'estándar', me gustaría ir con -1 (todos de 1 en binario). Este valor se extiende a lo booleano tamaño que desee (de un solo bit, de 8 bits, 16, etc.), y si se rompe un "verdadero" o "falso" en un pequeño "verdadero" o "falso", su todavía lo mismo. (Donde si se rompió una 16 bits = TRUE 0x0001 que obtendría un falso = 0x00 y 0x01 a = TRUE).

Answer 10

Diseñar el lenguaje para que 0 es falsa y no nula es verdadera. No hay necesidad de "convertir" nada, y pensando "no cero" en lugar de algún valor específico le ayudará a escribir el código correctamente.

Si usted tiene símbolos incorporados como "True" y luego seguir adelante y elegir un valor, pero siempre piensan "distinto de cero es verdad" en lugar de "0x01 es cierto".

Answer 11

Haga lo que haga, una vez que seleccione sus valores no cambian ellos. En Forth-77, verdadero y falso se definieron como 1 y 0. Entonces, adelante-83 les redefine como -1 y 0. Había un no pocas (bueno, está bien, sólo unos pocos, esto es ADELANTE estamos hablando de problemas) causado por esto.