Introdução aos números inteiros

Nesta seção examinaremos a representação de números inteiros no computador.

Sequência de bits (e bytes) para representar um inteiro

Toda informação no computador digital é composta por bits, em particular todo símbolo ou caractere é representado por um número fixo de bits, sendo que geralmente usa-se uma quantidade fixa de bits para representar qualquer caractere, por exemplo, a sequência binária `1000001` equivale ao caractere `A` ('a' maiúsculo). Mas o binário `1000001` é correspondente ao número decimal 26+20 = 64+1 = 65, assim o caractere `A` está associado ao número `65` (vide explicação sobre código ASCII).

Quantos inteiros conseguimos com 8 bits

Assim, o número de bits utilizados para representar os inteiros define o intervalo de inteiro que podemos conseguir. Por exemplo, se dispomos de 8 bits, que é denominado um bytes, podemos conseguir até 28 diferentes valores, pois podemos usar desde `00000000` até o binário `11111111`.

Portanto, se o computador tivesse apenas 8 bits para representar inteiros positivos, poderíamos ter desde o `00000000` (correspondendo ao decimal 0) até o binário `11111111`, que correspondente ao decimal 20 + 21 + 22 + 23 + 24 + 25 + 26 + 27 = 1+2+4+8+16+32+64+128 = 256-1 = 255.

Mas se precisarmos dos inteiros negativos, poderíamos usar o primeiro bit para o sinal (1 indicando negativo) ou fazer o complemento binário ("invertendo" os bits). No primeiro caso, com os mesmos 8 bits, poderíamos ir desde `-127` (-26-25-...-21-20) até `127`, mas perderíamos uma entrada (tanto `10000000`, quanto `00000000` poderiam ser associadas ao 0). Essa associação, que não é utilizada na prática, está ilustrada na terceira coluna da tabela ao lado.

A outra opção, denominada complemento de dois, podemos variar de `-128` até `127`, como indicado na segunda coluna da tabela ao lado. Nessa representação para obter o negativo de um número deve-se aplicar dois passos:

1. Inverter os bits do número e depois somar um.
   Exemplo 1. Para o 127 cujo binário é `01111111`: inverte `10000000` e soma-se um, resultando `10000001` (-127). Exemplo 2. Para o 126 cujo binário é `01111110`: inverte `10000001` e soma-se um, resultando `10000010` (-126). Exemplo 3. Para o 1 cujo binário é `00000001`: inverte `11111110` e soma-se um, resultando `11111111` (-1).

Assim, nessa representação existe um negativo a mais, no caso o -128, que é `10000000`, pois ao somar `10000000` com `01111111` (que é o decimal 127) obtém-se `11111111` que é o decimal -1 (exemplo 3), ou seja, -128 + 127 = -1.

`01111111`
`+`
`10000000`
`--------`
`11111111`

Na tabela 1 apresentamos os binários entre 00000000 e 11111111, mostrando seu correspondente decimal usando a técnica de complemento de dois (coluna do meio) e a conversão usual para decimal (coluna da direita). Na conversão matemática usual, deve-se usar o valor do bit (digito) multiplicado por sua potência. Por exemplo, o primeiro binário 00000000 é 0, pois é 0 x 2k para todo natural k, por outro lado o binário 00010011 é 19, pois é 1 x 24 + 1 x 21 + 1 x 20 = 16 + 2 + 1 = 19.

Tab. 1. Exemplo de números binários e seu correspondente decimal usando complemento de dois e decimal usual

Número binário | decimal com sinal (complemento) | decimal sem sinal
--- | --- | ---
`00000000` | `0` | `0`

`00000001`

`1`

`1`

`00000010`

`2`

`2`

`00000011`

`3`

`3`

`00000100`

`4`

`4`

`00000101`

`5`

`5`

`...`

`...`

`...`

`01111110`

`126`

`126`

`01111111`

`127`

`127`

`10000000`

`-128`

`128`

`10000001`

`-127`

`129`

`10000010`

`-126`

`130`

`10000011`

`-125`

`131`

`...`

`...`

`...`

`11111101`

`-3`

`253`

`11111110`

`-2`

`254`

`11111111`

`-1`

`255`

Inteiros com dois bytes (ou 16 bits)

Claramente 8 bits (que equivale a um byte) resulta em um intervalo para trabalho bastante limitado. Se dobrarmos o número de bits, passando a usar 16 bits, ou dois bytes, melhoramos bastante o intervalo de inteiros que podemos usar. Nesse caso, o número de possibilidades distintas é de 216=65536, o que possibilita os inteiros sem sinal desde o `0` até o `65535`.

Considerando inteiros negativos, usando a representação com complemento de dois, conseguimos representar desde o -32768 até o 32767.

Leônidas de Oliveira Brandão
http://line.ime.usp.br

Alterações:
2020/08/15: novo formato, pequenas revisões