Até aqui, atravessamos a estrada pela introdução tentando fazer deste apinhado de códigos uma experiência agradável, compreensível e não traumática.

O importante é que você realmente entenda passo a passo e sem pular um único parágrafo sequer. É de fato um desafio grande, para mim que escrevo e para você que lê.

Estamos chegando juntos ao momento de começarmos a programar, ao final destas etapas introdutórias e conceituais. Está quase na hora de começarmos a botar a mão na massa.

No texto anterior expliquei como se fazem as conversões entre as bases numéricas. Agora vamos deixar de ver a matemática abstrata dos sistemas numéricos e focar mais na máquina, em suas características, suas capacidades e limitações.

Para isto, precisamos acertar juntos nossos ponteiros sobre as unidades de medida numéricas dos computadores. Desta forma falaremos a mesma língua e tudo começará a fluir com mais velocidade e eficiência, dobrando a curva de aprendizagem e aumentando a absorção do conteúdo.

Eu estou caprichando nestes textos, com o intuito de produzir o melhor curso de Assembly possível para quem deseja aprender de verdade, não estou cobrando um único centavo de ninguém e o que eu exijo [sim, eu exijo] é um aproveitamento mínimo de 100%. Não admito nenhum dos seguidores deste curso com dúvidas naquilo que foi ensinado e me coloco a disposição em tempo integral para responder quaisquer questões. Estou aqui para isto mesmo e você para se esforçar e se sobressair sobre todos os demais profissionais da área.

Eu quero que você seja bom, não medíocre, não técnico, mas capaz de programar de verdade, sem receios de qualquer desafio. Estou preparando vocês para um Brasil melhor, um Brasil cujo segundo setor da economia acumula um déficit de 17 bilhões de dólares em patentes vencidas para o exterior, devido a falta de engenheiros para indústria. Há futuro para vocês neste curso. Não o desperdicem.

Se você não acredita em si mesmo, está no lugar errado, pois embora eu não conheça, sei que simplesmente por você ter chegado até aqui, buscando informação de qualidade, eu já acredito em você e tenho motivos para tal.

Eu não quero menininhos mimados de apartamento metidos a hacker. Quero pessoas de fibra, homens e mulheres dispostos a produzir máquinas para o mundo real, para a agricultura, pecuária, mineração e etc. O Brasil precisa de vocês e isto não é mais uma escolha: vocês tem essa responsabilidade. Responsabilidade. Com o coração nas mãos eu jogo todo peso do mundo em vossas costas. Se virem, vocês podem!

Unidades de medida dos bits

Aprendemos onde, como e porque surgiram os bits, agora vamos ver aqui como o computador lida com eles.

O bit, dígito binário (binary digit) é a menor unidade de informação possível e pode assumir dois valores possíveis: 0 (zero) e 1.

Acontece que o computador usa recursos eletrônicos para registrar as informações e portanto os números, para o computador, não são processados como no nosso cérebro.

Para nós, basta ir somando e acrescendo ou diminuindo casas decimais. Para o computador não é assim, ele depende de circuitos eletrônicos, e como já estudamos, para cada bit há um circuito. Os circuitos que guardam os conjuntos de bits são chamados “registradores“.

Os primeiros registradores tinham apenas 4 bits. Isto significa que guardavam os números binários de 4 em 4. Se fosse um humano querendo guardar o número 1 por exemplo, apenas memorizaria, ou escreveria em um papel “1“. Acontece que o computador não é humano e como registra 4 bits por vez, o número 1 seria registrado da seguinte forma: “0001“.

O computador separa os bits de 4 em 4, isto pode parecer confuso à primeira vista, mas nos ajuda muito a trabalhar com bits, classificando os grupos e os nomeando como grandezas da computação, de acordo com as suas quantidades.

O bit é apenas um dígito binário. Quando é registrado em um conjunto de 4 bits, recebe o nome de “nibble”. Se são 8 bits, ou dois nibbles, são chamados “byte”. Se são 16 bits, ou 4 nibbles, ou 2 bytes, são chamados “word“.

assembly - unidades de medida de bits

Se alguém nos disser que precisamos de 8 bits para uma operação, isto significa que precisamos de 1 byte, ou de 2 nibbles, ou de meio word, tanto faz, a contagem de bits é a mesma.

Isto ainda vai complicar um pouco mais para frente, mas tenho boas notícias: primeiro que por hora é tudo que precisamos e segundo que as demais unidades de medida não são de bits, mas de bytes e que já são todas conhecidas por nós, como mega, giga, tera e etc.

Os bits que valem mais

Quando consideramos um nibble por exemplo, sabemos que estamos falando de um conjunto de 4 bits.

Se convertermos um número binário escrito em um nibble para decimal, vamos descobrir que os primeiros bits, valem menos e quem os últimos valem mais. Suponha o nibble: 1111.

assembly nibble

O primeiro bit vale 1, o segundo vale 2, o terceiro vale 4 e o quarto vale 8.

O bit que tem menos valor é o primeiro, que vale 1, é portanto o bit menos significativo.

O bit que tem mais valor é o último, que vale 8, é portando o bit mais significativo.

assembly bit menor e bit maior

Você encontrará nas literaturas a respeito algumas referências como:

  • bit mais baixo” e “bit mais alto
  • bit menor” e “bit maior
  • bit de baixa ordem” e “bit de alta ordem

Observação: eu, enumero as posições dos bits de acordo com o seu valor em uma conversão, isto no entanto não é um padrão. Há em outras literaturas, outras formas de enumerá-los. Você inclusive pode querer lê-los de forma inversa por exemplo e isto não é nenhum problema, contanto que tenha em mente seus valores sempre.

A mesma regra para outras grandezas

A mesma regra que expus no capítulo anterior vale para outras grandezas. Por exemplo se ao invés de um nibble, considerarmos um byte ou word.

assembly bit menor e bit maior

Até aqui isto deve estar muito claro: os bits menor e maior são sempre respectivamente o primeiro e o último.

Grandezas maiores, como byte e word, podem ser vistas também como compostas por grandezas menores.

Um byte por exemplo, contém 2 nibbles e para classificar os nibbles de um byte, a regra é a mesma dos bits. Atente:

assembly nibbles byte

Já um word contém 4 nibbles e segue a mesma regra. Observe:

assembly nibbles word

Um word ainda pode ser divido em 2 bytes e a mesma regra pode ser aplicada:

assembly bytes word

Voltando um pouco à matemática: números inteiros

Com os conjuntos de bits anteriores podemos trabalhar com números, tanto nos sistemas binário, decimal e hexadecimal, quanto outros sistemas numéricos que aqui não abordaremos.

Com 8 bits, podemos escrever de 00 (zero, zero) até FF, em hexadecimal, que significa de 0 (zero) até 255 no nosso sistema decimal. Acontece que no nosso mundo, lidamos com ganhos e perdas, com excesso e falta, e matematicamente isso significa positivo e negativo.

Em matemática, aprendemos primeiro os números naturais, ou seja, do zero em diante, somando infinitamente, sem contar a existência dos negativos. Em seguida aprendemos os números inteiros, onde os negativos dos números naturais existem. Para os inteiros, se existe o número natural “1“, existe seu oposto “-1” e o mesmo vale para todos os números.

Para representar os números negativos nos inteiros, é necessário colocar o sinal de menos antes: -1, -2, -3, e etc.

Como fazemos isto usando bits que só aceitam os números 1 e 0 (zero)?

O bit do sinal

A partir dos bytes, ou seja, conjuntos de 8 bits, podemos fazer isto separando o último bit. Este é o chamado “bit do sinal“.

Ao escrever um número com sinal no sistema binário com 8 bits, a expressão fica da seguinte forma:

assembly bit do sinal

A cadeia de bits então fica dividida em duas partes: 1 bit para o sinal e 7 bits para escrever o número em si.

Quanto ao “bit do sinal“, se este for 1 o número será negativo e se for 0 (zero) será positivo.

Quando em uma cadeia de bits, como um byte por exemplo, separamos um bit, sobram 7.

Com 7 bits não podemos escrever de 0 (zero) até 255, mas de 0 (zero) até 127. Desta forma, considerando 8 bits (um byte), ficamos com 2 grupos de números inteiros:

  1. os positivos: com o bit do sinal contendo 0 (zero)
  2. os negativos, com o bit do sinal contendo 1

O “bit do sinal” é sempre o mais significativo, aquele que na hora da conversão para hexadecimal ou decimal representa um valor mais alto, como já vimos antes.

Separado o bit do sinal, de 8 bits, sobram 7 bits para cada lado. 7 bits para os positivos e 7 bits para os negativos.

Considere um byte (8 bits):

  • 0000 0000: como o bit do sinal é 0 (zero), o número é positivo. Com os outros 7 bits podemos escrever até 127 compreendendo o intervalo de 0000 0000 até 0111 1111.
  • 1000 0000: como o bit do sinal é 1, o número é negativo. Com os outros 7 bits podemos escrever até -128 compreendendo o intervalo de 1000 0000 até 1111 1111.

Repare a figura abaixo:

assembly inteiros

Acontece que para representar números negativos, não basta modificar o bit do sinal. Há uma regra aí que vamos examinar agora.

Inteiros positivos e negativos: o complemento de dois

O assim chamado “complemento de dois” é uma espécie de fórmula para converter números binários positivos em negativos.

Nós já sabemos que quando o último bit é zero, o número é positivo. Se for 1, é negativo. No caso de um conjunto de 8 bits (um byte) é o oitavo bit.

A fórmula do “complemento de dois” é composta de 2 passos muito simples:

  1. Invertemos todos os bits
  2. Somamos 1 ao resultado

Só isso. Só isso e mais nada! 😀

Vamos à prática. Suponha o decimal 2:

  • 0000 0010 (2 decimal, escrito em binário)
  • 1111 1101 (inverte todos os dígitos)
  • 1111 1110 (soma 1)

Este número: 1111 1110 é o equivalente ao “-2” escrito em binário.

O último bit é o “bit do sinal“, como já expliquei. Os próximos 7 bits (111 1110) são o número decimal -2. Estranho né?! Explico abaixo.

Com uma sequência de 8 bits, ou 1 byte, é possível escrever de 0 (zero) até 255. Ao todo são 256 números possíveis de serem representados. Com isto, temos a quantidade: 256. Se pegarmos toda cadeia de bits resultante da operação anterior: 1111 1110 e a convertermos para o decimal obtemos: 254. Basta agora diminuir do total de números com 8 bits (256), o número obtido (254): 256 – 254 = 2.

  • 256 (quantidade de números possíveis entre 0 (zero) e 255 com 1 byte, 8 bits)
  • 254 (resultado da última operação: 1111 1110)
  • 256 – 254 (subtraímos do total possível o número obtido)
  • 256 – 254 = 2 (o resultado é o número negativo que procuramos)

É fácil não? É sim.

O computador sabe que quando se trata de números com sinal, o último bit é o “bit do sinal“, se ele encontrar o número 1 ali, é isto que ele faz: diminui do total, o número encontrado, o resultado é o número negativo representado.

É assim que o computador representa os números negativos com os recursos eletrônicos que possui através de números binários.

Cuidados de adaptação entre grandezas

Percebam que até aqui usamos apenas o byte, ou seja uma cadeia de 8 bits.

Acontece que podemos desejar que o tamanho de um dado fosse maior ou menor e isto exige alguns cuidados.

Por exemplo: um byte possui 8 bits e um nibble possui 4, converter um byte para um nibble ou nibble para byte requer cuidados e estes mesmos cuidados se aplicam entre todas as diferentes grandezas: nibble, byte, word e demais que ainda não vimos.

Cuidados: aumentando bits

O que aconteceria se aumentássemos um byte (8 bits), com um número binário escrito, para um word (16 bits) por exemplo?

Suponha o número com sinal 1001 1001. Ele se tornaria: 0000 0000 1001 1001 e estaria errado, pois o bit do sinal estaria agora preenchido com 0 (zero) ao invés de 1.

O número com sinal original, 1001 1001, escrito em um byte,  quando convertido para decimal representa -103.

Se for simplesmente estendido de 8 para 16 bits e completado com 8 zeros nas novas casas o resultado será 0000 0000 1001 1001, que quando convertido para decimal representa 153.

Em um byte, o decimal correspondente é o -103, enquanto em um word é 153. Não apenas o valor foi modificado como o sinal também, de negativo para positivo.

Ou seja, fazer desta forma é errado, vamos então aprender o correto.

Para aumentar o número de bits, a forma correta é copiarmos o bit do sinal para os novos bits, assim o número binário 1001 1001 escrito em um byte (8 bits), ao ser adaptado para word (16 bits), seria escrito da seguinte forma:

  • 1001 1001 (número original de 8 bits)
  • 1 (destacamos o bit do sinal)
  • 1111 1111 1001 1001 (copiamos o bit do sinal para as novas casas)

O binário com sinal 1001 1001, escrito em um byte (8 bits), representa -103. Adaptado desta forma resultou no word (16 bits) 1111 1111 1001 1001, que continua representando o mesmo número decimal -103.

E se fosse um número positivo? Supondo o binário 0011 0100, basta aplicar a mesma regra.

  • 0011 0100 (número original de 8 bits)
  • 0 (destacamos o último bit)
  • 0000 0000 0011 0100 (copiamos o bit do sinal para as novas casas)

O binário com sinal 0011 0100, escrito em um byte (8 bits), representa o decimal 52. Ao ser estendido para word (16 bits) resultou no binário 0000 0000 0011 0100, que representa o mesmo decimal 52.

Aplicando esta regra, o resultado sempre será seguro, pois o número binário escrito é o mesmo para positivos e negativos.

Atenção: esta regra vale exclusivamente para números com sinal, para números sem sinal não devem ser aplicadas.

E caso precisemos diminuir o número de bits? Vamos ver isto agora.

Cuidados: diminuindo bits

Ao contrário do que vimos no caso anterior, podemos em algum momento decidir que reduziremos o tamanho de um número binário escrito em uma grandeza maior, para uma grandeza menor. Por exemplo, reduzir um número escrito em um word (16 bits) para um byte (8 bits), ou de um byte para um nibble (4 bits).

O número binário 1001 1001, de 8 bits, pode ser escrito com 4 bits? Não, vejamos o motivo.

Para reduzir o número de bits de um byte para um nibble, como no caso acima, precisamos excluir o nibble mais alto. Acontece que isto alteraria o valor do dado.

  • 1001 1001 (byte, 8 bits, que corresponde ao decimal –103)
  • 1001 1001 (cortamos o nibble mais alto e ficamos apenas com o nibble mais baixo)
  • 1001 (nibble, 4 bits, o decimal resultante é -7)

Repare que ao cortarmos o nibble mais alto, ele estava preenchido com valores, disto resultou que o decimal inicial -103, fosse alterado para -7. Obviamente um erro.

Alguém poderá pensar que o problema é por tratar-se de um número com sinal, ou por se tratar de um negativo. Não, não é por este motivo. O motivo é porque o nibble mais alto está preenchido já e quando for alterado o valor representado também sofrerá alterações. Vamos supor um positivo então.

  • 0101 0101 (byte, 8 bits, corresponde ao decimal 85)
  • 0101 0101 (cortamos o nibble alto e guardamos o nibble baixo)
  • 0101 (nibble, 4 bits, cujo decimal resultante é 5)

Novamente, ao cortarmos o nibble mais alto que estava preenchido alteramos o valor do dado, de 85 obtivemos 5. Mais uma vez errado.

Até aqui sabemos que quando houverem valores já preenchidos no dado, não podemos reduzi-lo.

No entanto, ainda assim não estamos seguros.

Suponha o binário 0000 1001, vamos experimentar reduzi-lo, uma vez que o nibble superior está repleto de zeros:

  • 0000 1001 (byte, 8 bits, representa o decimal 9)
  • 0000 1001 (cortamos o nibble alto e guardamos o nibble baixo)
  • 1001 (nibble, 4 bits, decimal resultante -7)

O número inicial representado era o decimal 9, o que obtivemos foi -7. Novamente errado! Perceba que não bastou que o nibble alto estivesse repleto de zeros, pois o bit do sinal do nibble acabou ficando preenchido e portanto o valor e o sinal foram alterados.

Das experiências acima, podemos deduzir uma regra agora: Não é seguro reduzir bits em um dado.

Entendido?

Isto não se aplica apenas entre bytes e nibbles, mas à quaisquer grandezas: word para byte e demais.

Vamos então pensar maior. Trabalhemos com word então, com 16 bits.

Atente para a redução abaixo de word para byte:

  • 0000 0001 0011 0101 (word, 16 bits, decimal 309)
  • 0000 0001 0011 0101 (cortamos o byte alto)
  • 0011 0101 (byte, 8 bits, o resultado é o decimal 53 e portanto errado)

Pode testar você mesmo com positivos e negativos, e números com ou sem sinal. Pode ser que dê certo sob determinadas circunstâncias, mas para um programador esta não é uma boa prática.

Cuidados: conclusão

O que se pode tirar de lição prática disto?

Uma regra: aumentar bits em um dado é possível com segurança se copiarmos o bit do sinal para as novas casas.

Reduzir o tamanho no entanto não é seguro.

Lembre-se que você estará o tempo todo trabalhando com decimais e hexadecimais, raramente com binários, portanto não vale a pena o esforço neste caso.

O melhor, é medir antes o intervalo de dados que você trabalhará para depois definir o número de bits que reservará: é uma questão de segurança.

Suponha que você precisa trabalhar com anos. Um ano geralmente usa 4 dígitos decimais. Estamos por exemplo, hoje em 2018. 2018 pode ser escrito com 2 bytes, que comporta, sem sinal, de 0 (zero) até 65535. Basta que você reserve 2 bytes para este dado em seus programas e jamais terá problemas (a menos é claro, que seu programa ainda esteja em uso na virada do ano 65535 para o próximo, o que eu realmente acho muito improvável).

Calculadora: um conselho de amigo

Durante o aprendizado, esforce-se para realizar todos estes cálculos a mão mesmo, mas no dia a dia use uma calculadora, pois profissionalmente a precisão dos números é uma exigência.

Outra perspectiva do bit

Pelo bit ser uma unidade mínima de informação e seus estados possíveis serem então o 0 (zero) ou 1, isto significa que podemos representar quaisquer valores opostos. Por exemplo: sim ou não, verdadeiro ou falso, certo ou errado, ligado ou desligado, e por aí vai.

Como unidade de informação, podemos nos servir para registrar valores do mundo real que não se tratem exclusivamente de matemática e operações numéricas: podemos lidar com lógica.

Operações lógicas

Peço muita atenção a esta parte do texto, pois isto você usará o resto da vida em computação.

Em lógica, testamos se algo é verdadeiro ou falso.

As operações lógicas são “E“, “OU” e “NÃO“.

Suponha a seguinte sentença:

Seu pai E sua mãe foram ao shopping.

Esta afirmação só poderá ser verdadeira caso ambos tenham ido ao shopping. Se, pelo contrário apenas sua mãe foi, ou apenas seu pai, ou ainda nenhum dos dois, a afirmação será considerada falsa.

Para representar isto com números binários, existe a “tabela verdade“, observe:

assembly tabela verdade E

Na tabela acima, considere na primeira linha as pessoas (seu pai e sua mãe) e o resultado se verdadeiro ou falso: 1 para verdadeiro e 0 (zero) para falso.

As linhas logo abaixo são as situações.

Na segunda linha, seu pai = 0 (não foi), sua mãe = 0 (não foi também), o resultado para 0 E 0 = falso, 0 (zero).

Na terceira linha, seu pai = 1 (ele foi), sua mãe = 0 (não foi), o resultado para 1 E 0 = falso, 0 (zero).

Na quarta linha, seu pai = 0 (não foi), sua mãe = 1 (ela foi), o resultado para 0 E 1 = falso, 0 (zero).

Na última linha, seu pai = 1 (foi), sua mãe = 1 (também foi), o resultado para 1 E 1 = verdadeiro, 1.

Repare que a representação dos dados aqui, usa 0 (zero) para falso e 1 para verdadeiro: isto é extremamente importante e te será importante para sempre como programador.

Agora, vamos supor a sentença a seguir:

O cachorro OU o gato estão no quintal.

A afirmação acima, só poderá ser verdadeira caso o cachorro, o gato, ou ambos estejam no quintal. Caso nenhum deles esteja no quintal, a sentença será falsa.

Observe abaixo a “tabela verdade” para a operação apresentada neste caso:

assembly tabela verdade OU

Na tabela acima, a primeira linha são os animais (cachorro e gato) e o resultado da questão, se estão OU não no quintal, em binário.

Na segunda linha, cachorro = 0 (não está no quintal), gato = 0 (também não está), o resultado para 0 OU 0 = 0 (zero), falso.

Na terceira linha, cachorro = 1 (está), gato = 0 (não está), o resultado para 1 OU 0 = 1, verdadeiro.

Na quarta linha, cachorro = 0 (não está), gato = 1 (está), o resultado para 0 OU 1 = 1, verdadeiro.

Na última linha, cachorro = 1 (está), gato = 1 (também está), o resultado para 1 OU 1 = 1, verdadeiro.

Perceba que todos os dados, o cachorro, o gato e os resultados, foram representados como verdadeiros ou falsos, usando os números binários 0 (zero) e 1.

Este que vimos acima é o chamado “OU inclusivo” pois aceita como verdadeira a avaliação de uma sentença onde ambas as opções sejam um, simultaneamente verdadeiras, conforme demonstrado na última linha da tabela. Há também o “OU exclusivo“, que só aceita como verdadeira a avaliação quando apenas 1 dos dados for verdadeiro. Vamos examiná-la a seguir.

Suponha a sentença:

O rapaz que mergulhou, deve estar voltando OU se afogou.

Este é um caso no qual as duas opções: estar voltando e se afogar não podem ser verdadeiras simultaneamente. Para este tipo de sentença é que serve o OU exclusivo.

assembly tabela verdade OU exclusivo

A sentença só poderá ser verdadeira caso o rapaz esteja voltando, ou caso caso ele tenha se afogado. Qualquer hipótese contrária será falsa.

Na segunda linha, voltando = 0 (falso), afogado = 0 (falso), portando o resultado é 0 (zero) e a sentença é falsa.

Na terceira linha, voltando = 1 (verdadeiro), afogado = 0 (falso), o resultado é 1 (verdadeiro).

Na quarta linha, voltando = 0 (falso), afogado = 1 (verdadeiro), o resultado é 1 (verdadeiro).

Na última linha, voltando = 1 (verdadeiro), afogado = 1 (verdadeiro), e o resultado é 0 (falso).

Por último vamos explorar a negação, o NÃO.

Suponha a sentença a seguir:

A bola NÃO é redonda.

Montando a “tabela verdade“, obtemos a seguinte configuração:

assembly tabela verdade NÃO

Na segunda linha, a afirmação de que a bola NÃO é redonda é negada, é 0 (zero), portanto a sentença é verdadeira, é 1.

Na terceira linha, a mesma afirmação é confirmada, é 1, portanto o resultado é falso, 0 (zero).

Qualquer um que afirmar que uma bola não é redonda estará mentindo, estará fazendo uma afirmação falsa. Aqui, representamos com números binários estes dados.

É importante notar que para todas as operações com bits apresentadas acima, foram tratadas comparações e é disto que se tratam as operações lógicas: comparações.

Em programação, comparamos dados para tomada de decisões, isto você precisa ter sempre em mente pois quando entrarmos em fluxo de procedimentos (lá na frente), você precisará estar preparado e muito bem preparado.

A tabela ASCII

Quando abordei os números com e sem sinal, naturais e inteiros, positivos e negativos, expliquei que sacrificamos um bit, o último bit, o “bit do sinal” em um byte e assim sobram apenas 7 bits, com os quais podemos escrever os decimais de 0 a 127.

A empresa IBM, no passado resolveu padronizar um código numérico que abrange todos os 127 positivos. É a chamada “tabela ASCII“.

A sigla “ASCII” significa: “American Standard Code for Information Interchange“, cuja tradução é “Código Padrão Americano para o Intercâmbio de Informação“. Sucede que na altura, os computadores já eram capazes de realizar muitas outras atividades além de contar e calcular. Uma delas era editar textos. O problema é que, para se trabalhar com textos, cada programador e cada empresa criavam sua própria codificação, ou seja, usavam números binários diferentes para representar caracteres de texto diferentes e um caractere gravado em um computador poderia significar outro em outro computador. Isto estava crescendo e se tornando um problema sério.

Quando um computador salva um texto, a letra “A” por exemplo, não é gravada como uma letra, ela é gravada como um número binário e o computador realiza a conversão entre números binários e caracteres de texto através do sistema operacional. Por exemplo, quando você aperta uma tecla no seu teclado, um sinal elétrico é enviado pelo fio até o conector da placa eletrônica do seu computador, que entrega o sinal para o processamento interno. Então o sistema operacional procura o correspondente número binário na tabela ASCII gravada na memória, converte o sinal no símbolo adequado e então apresenta o caractere encontrado no monitor. Esta é a mágica toda.

Os 127 primeiros números decimais, convertidos em binário são padronizados, os demais 128 caracteres restantes não são, eles podem portanto variar de um sistema operacional para outro.

A tabela ASCII está dividida em 4 grupos de 32 caracteres cada.

  1. Caracteres de controle não imprimíveis, como “quebra de linha“, “retorno de carro” e “back-space
  2. Números decimais de 0 a 9
  3. Letras de “A” até “Z” maiúsculas
  4. Letras de “a” até “z” minúsculas

Uma curiosidade importante:

  • o grupo das letras maiúsculas começa pelo binário 0100 0001
  • o grupo das letras minúsculas começa pelo binário 0110 0001

A única diferença entre o começo de um grupo e o começo do outro, é o sexto bit: 0100 0001 / 0110 0001.

Isto significa que para mudar uma letra de maiúscula para minúscula, tudo que o programador precisa fazer é mudar o bit correspondente.

Perceba também que os grupos são identificados pelos nibbles mais relevantes.

Como não usaremos o computador para fazer contas apenas, conhecer os caracteres desde sua natureza é importante para nós.

Para os curiosos, deixo aqui a documentação original da tabela ASCII.

Este slideshow necessita de JavaScript.

Espero que o conteúdo até aqui esteja bastante claro, estudem bastante pois estamos próximos de começar a programar, uma vez que os conhecimentos introdutórios já estão se esgotando.

Existem duas operações com bits que não abordei neste texto para não ficar mais extenso: rotação e deslocamento, que abordarei no próximo.

Testes:

Só avance quando for capaz de responder às seguintes questões.

  1. Quais são as grandezas (unidades de medida) dos grupos de bits?
  2. Como se representam os números negativos em binário?
  3. Como funciona o complemento de dois?
  4. Quais o problemas em aumentar ou diminuir o número de bits?
  5. Qual é a regra segura para aumentar bits em um número com sinal?
  6. O que é melhor usar, a calculadora ou a mão, para fazer cálculos em seus trabalhos profissionais?
  7. Apresente uma perspectiva diferente do uso de bits, além da representação de números.
  8. No que se baseiam as operações lógicas?
  9. Quais são as operações lógicas?
  10. Proponha-se 5 operações lógicas de cada uma das apresentadas e resolva-as sozinho.
  11. Por que foi criada a tabela ASCII?
  12. Quantos são os grupos da tabela ASCII?

Se sozinho você não conseguir respondê-las, não prossiga, tire suas dúvidas até que realmente entenda o assunto e só depois prossiga.

No texto seguinte vamos concluir as operações com bits, acrescentando deslocamento e rotação, falar de empacotamento de dados e dar início à organização da memória.

Em caso de dúvidas peço que me escrevam sem hesitar: ricardo.roveran@hotmail.com

Assembly – Operações com bits, números com sinal e tabela ASCII

Anúncios