Boolean true - positivo ou negativo 1 1?

Question

Eu estou projetando uma língua, e tentando decidir se true deve ser 0x01 ou 0xFF. Obviamente, todos os valores diferentes de zero serão convertidos em verdade, mas eu estou tentando decidir sobre a representação interna exato.

Quais são os prós e contras de cada escolha?

Answer 1

0 é falsa porque o processador tem uma bandeira que é definido quando um registo está definido para zero.

Não há outras bandeiras são definidas em qualquer outro valor (0x01, 0xff, etc.) - mas a flag zero é definido como falso quando há um valor diferente de zero no registo

Assim, as respostas aqui defendendo definir 0 como falso e qualquer outra coisa como verdade estão corretos.

Se você quiser "definir" um valor padrão para verdadeiro, então 0x01 é melhor do que a maioria:

• Representa o mesmo número em cada comprimento de bits e de assinatura
• É preciso apenas testando um pouco se você quer saber se é verdade, se a flag zero não estar disponível, ou caro para uso
• Não há necessidade de se preocupar com a extensão de sinal durante a conversão para outros tipos
• Lógica e expressões aritméticas agir da mesma sobre ele

-Adam

Answer 2

Não importa, desde que satisfaça as regras para a representação externa.

Gostaria de dar uma dica de C aqui, onde falsa é definido absolutamente como 0, e verdadeiro é definido como não falsa. Esta é uma distinção importante, quando comparado com um valor absoluto para a verdadeira. A menos que você tem um tipo que só tem dois estados, você tem que conta para todos os valores dentro desse tipo de valor, o que é verdadeiro eo que é falso.

Answer 3

Por que você está escolhendo que valores diferentes de zero são verdadeiras? Em Ada verdadeiro é verdadeiro e falso é FALSE. Não há nenhum tipo de conversão implícita de e para BOOLEAN.

Answer 4

Usando -1 tem uma vantagem em uma linguagem fracamente tipado - se você mexer-se e usar o operador bit a bit and em vez do operador and lógico, sua condição ainda irá avaliar corretamente, desde que um dos operandos foi convertido em a representação booleano canónica. Isso não é verdade, se a representação canônica é 1.

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

e

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

Answer 5

IMO, se você quiser ficar com false = 0x00, você deve usar 0x01. 0xFF é geralmente:

• um sinal de que alguma operação transbordada

ou

• um marcador de erro

E em ambos os casos, isso provavelmente significa false . Daí o valor nix retorno convenção * de executáveis, que true = 0x00, e qualquer valor diferente de zero é falso.

Answer 6

-1 é maior para digitar de 1 ...

No final, não importa desde que 0 é falso e qualquer outra coisa é verdade, e você nunca vai comparar com a representação exata do verdadeiro.

Editar, para aqueles de votação para baixo, por favor, explique o porquê. Essa resposta é essencialmente o mesmo que o atualmente avaliado em +19. De modo que é de 21 votos diferença para o que é a mesma resposta básica.

Se é por causa da -1 comentário, é verdade, a pessoa que realmente define "true" (por exemplo: o escritor compilador) vai ter que usar -1 em vez de 1, assumindo que eles escolheram para usar um representação exata. -1 vai levar mais tempo ao tipo do que um, e o resultado final será o mesmo. A afirmação é bobo, ele foi concebido para ser bobo, porque não há nenhuma diferença real entre os dois (1 ou -1).

Se você estiver indo para marca de algo para baixo, pelo menos, fornecer uma razão para isso.

Answer 7

0xff é uma escolha estranha, uma vez que tem um pressuposto implícito de que 8 bits é a sua unidade de armazenamento mínimo. Mas não é assim tão raro deseja armazenar valores booleanos mais compacta do que isso.

Talvez você queira reformular pelo pensamento sobre se operadores booleanos produzir algo que é apenas um 0 ou 1 bit (que funciona independentemente da extensão de sinal), ou é todo-zeros ou todos-os (e depende de extensão sinal de assinado quantidades complemento de dois para manter todo-queridos em qualquer comprimento).

Eu acho que sua vida é mais simples com 0 e 1.

Answer 8

Os prós são nenhum, e os contras são nenhum também. Contanto que você fornecer uma conversão automática de inteiro para booleano, será arbitrária, por isso realmente não importa quais números você escolher.

Por outro lado, se você não permitir que esta conversão automática você teria um pro: você não teria alguma regra inteiramente arbitrária no seu idioma. Você não teria (7 - 4 - 3) == false, ou 3 * 4 + 17 == "Hello", ou "Hi mom!" == Complex(7, -2).

Answer 9

Eu acho que o método C é o caminho a percorrer. 0 significa falso, nada mais significa verdade. Se você vai com outro mapeamento de verdade, então você é deixado com o problema de ter valores indeterminados -. Que não são nem verdadeiro nem falso

Se esta é a linguagem que você vai ser a compilação de um conjunto de instruções específicas que tem o apoio especial para uma representação particular, então eu deixaria que guiá-lo. Mas na ausência de qualquer informação adicional, para uma representação interna 'standard', eu iria com -1 (todos os 1s em binário). Este valor se estende bem para o tamanho boolean que quiser (um único bit, 8 bits, 16, etc), e se você quebrar um "verdadeiro" ou "falso" em um menor "TRUE" ou "FALSE", o seu ainda o mesmo. (Onde se você quebrou um de 16 bits TRUE = 0x0001 você deseja obter um FALSE = 0x00 e um TRUE = 0x01).

Answer 10

Projeto do idioma para que 0 é falso e não-zero é verdadeiro. Não há necessidade de "converter" qualquer coisa, e pensar "não-zero" em vez de algum valor específico irá ajudá-lo a escrever o código corretamente.

Se você tem built-in símbolos como "True", em seguida, vá em frente e escolher um valor, mas sempre pensar "diferente de zero é verdade" em vez de "0x01 é verdade".

Answer 11

Faça o que fizer, uma vez que você seleciona seus valores não mudam eles. Em Forth-77, o verdadeiro eo falso foram definidos como 1 e 0. Em seguida, adiante-83 redefiniu-los como -1 e 0. Havia um não poucos (bem ok, apenas alguns, este é ADIANTE estamos falando) problemas causada por esta.