<AlissonB> FabioOlive, outra dúvida: http://www.bertochi.com.br/files/imagens/bits_a_esquerda.png

<AlissonB> o que ele quer dizer com “binários que utilizam o bit mais a esquerda”?

<FabioOlive> marlon: o AlissonB e eu esbarramos num bug da scanf(). se tu manda uma entrada que não casa com o padrão, as próximas chamadas da scanf() entram em loop sem ler uma nova linha

<marlon> Se não me engano é para representar numeros negativos

<FabioOlive> por isso que eu pensei em separar os dois passos

<marlon> unsigned é para numeros tipo de 256 ser -128 ate 127 e signed seria do 0 a 255

<FabioOlive> AlissonB: significa que o bit mais à esquerda pode ser interpretado como o sinal do número, se for um int (ou outro tipo inteiro). Se tu declarar uma variável int e colocar nela o valor 10000000'00000000'00000000'00000000 ela vai ser o número mais negativo representável em um int de 32bits

<FabioOlive> pensa assim

<FabioOlive> só tem bit nessa melda

<FabioOlive> computador é burro pacas

<FabioOlive> tudo é bit

<marlon> Ai para representar os negativos vai começa com 1 a esquerda para ser representado

<FabioOlive> e os bits não são mágicos nem infinitor

<FabioOlive> infinitos, digo

<FabioOlive> eles tão lá na memória

<FabioOlive> então se tu tem na memória uma variável de 32bits, vais armazenar lá 32 bits, e interpretar o que esses bits querem dizer depende do contexto

<FabioOlive> se o teu programa usa unsigned int, são 32 bits que podem representar de 0 até 2^32-1

<FabioOlive> se o teu programa usa int, então o bit mais na ponta vale como o sinal (na verdade o valor dele é -2^31)

<FabioOlive> é tudo uma questão de como interpretar os bits que estão lá

<FabioOlive> bit é bit, eles não carregam um marcador mágico que diga “eu sou um sinal!”

<FabioOlive> se tu pegar um valor negativo e colocar em uma variável unsigned, ele vai achar que é um valor bem grande ao invés de um valor negativo. :)

<FabioOlive> o processador não sabe o que é sinal e o que não é. é tudo bit, 0 e 1 na memória só

<marlon> FabioOlive: é mais o menos o que eu falei né? ou eu to viajando na maionese?

<AlissonB> em suma, em uma variável signed, o primeiro bit à esquerda sempre estará ligado?

<FabioOlive> quem tem que manter essa ilusão de que existem números negativos é o programador :)

<FabioOlive> AlissonB: não

<FabioOlive> AlissonB: só se o valor dela for negativo :)

<AlissonB> isso! :D

<FabioOlive> marlon: tu viajou um pouco :)

<_edEr> FabioOlive: mas o primeiro bit fica reservado pra essa finalidade ?

<AlissonB> boa pergunta _edEr++

<mibotz> _edEr tem 28 pontos de karma

<FabioOlive> não fica reservado

<FabioOlive> essa é uma boa pergunta mesmo _edEr++

<mibotz> _edEr tem 29 pontos de karma

<FabioOlive> vejam bem

<marlon> Manda ver ai FabioOlive :D

<FabioOlive> o bit lá da ponta vale uma potência de 2 “negativada” :)

<FabioOlive> vamos trabalhar com 8 bits pra facilitar

<FabioOlive> em um byte “sem sinal”, a gente sabe que os valores dos bits são (em ordem) 128 64 32 16 8 4 2 1

<FabioOlive> então em um byte cujos bits sejam 0 1 0 1 0 0 0 1 a gente soma 64 + 16 + 1 e chega no valor 81, certo?

<AlissonB> certo

<FabioOlive> então

<marlon> certo

<FabioOlive> se esse byte for “com sinal”, a gente faz de conta que o bit mais significativo, o da ponta esquerda, vale -128 ao invés de 128

<FabioOlive> então um valor como 1 1 0 0 1 0 1 0 ficaria -128 + 64 + 8 + 2, o que dá -54

<FabioOlive> vejamos se estou mentindo…

<marlon> Então quem faz este trabalho é o compilador ou o processador? ou nem um nem outro e é melhor eu ficar quietinho aqui ? ASHUASHAS

<AlissonB> huahuHHauhauhHUHAA

<FabioOlive> marlon: é o compilador que faz a mágica de fazer de conta que tem sinal. na verdade algumas instruções aritméticas do processador também fazem essa distinção, mas em geral não faz diferença

<marlon> Beleza (:

<AlissonB> muito bom!

<FabioOlive> $ cat negativo.c

<FabioOlive> #include <stdio.h>

<FabioOlive> int main() {

<FabioOlive> char byte = (char)0b11001010;

<FabioOlive> printf(”%d\n”, byte);

<FabioOlive> return 0;

<FabioOlive> }

<FabioOlive> $ gcc -o negativo negativo.c

<FabioOlive> $ ./negativo

<FabioOlive> -54

<FabioOlive> ufa!

<FabioOlive> achei que eu tinha errado hehehe

<AlissonB> 0b indica que é em binário?

<FabioOlive> sim

<FabioOlive> como 0x indica uma constante em hexa

<marlon> Muito boa explicação FabioOlive++ (:

<mibotz> FabioOlive tem 126 pontos de karma

<marlon> Obrigado õ/

<FabioOlive> que bom que gostaram! :)

<marlon> Galera, to indo para casa

<AlissonB> só uma dúvida, porque aquele cast pra char?

<marlon> Quando chegar entro no mirc lá :D

<AlissonB> valeu marlon

<marlon> irc * ASHHSAUASHUASH

<marlon> Abraços

<_edEr> abraço

<FabioOlive> AlissonB: só pra ter certeza que o compilador não ia reclamar :)

<AlissonB> testei sem FabioOlive, funfou também :)

<FabioOlive> legal

<FabioOlive> eu mudei o printf pra imprimir com e sem sinal :)

<FabioOlive> $ ./negativo

<FabioOlive> -54 4294967242

<FabioOlive> printf(”%d %u\n”, byte, byte);

<FabioOlive> :)

<FabioOlive> só muda a maneira de interpretar

<FabioOlive> (note que ele “promoveu” o char para um int na hora de imprimir)

<AlissonB> FabioOlive, mas esse número unsigned tá errado né o.O

<FabioOlive> não, esse número corresponde a 11111111'11111111'11111111'11001010 como um inteiro sem sinal :)

<FabioOlive> »> 0b11111111111111111111111111001010

<FabioOlive> 4294967242

<AlissonB> humm

<AlissonB> humm

<AlissonB> verdade, porque os inteiros tem 4 bytes né

<AlissonB> e o char é só 1 byte

<AlissonB> por isso tu salvou em um char

<AlissonB> :\o\

<FabioOlive> isso :)

<FabioOlive> pra facilitar e não ter que digitar os 32 bits todos

<AlissonB> agora as coisas estão fazendo sentido

<AlissonB> hehe

<FabioOlive> mas aí na hora de imprimir, o printf “promoveu” o char pra int, porque eu usei %d e %u que lidam com ints :)

<AlissonB> fantástico! FabioOlive++

<mibotz> FabioOlive tem 127 pontos de karma

<AlissonB> =D

<FabioOlive> e aí quando se estende um número de 8 bits pra 32, o último bit é repetido até o fim, para manter o sinal

<AlissonB> depois posto esse log lá no site

<_edEr> legal.. eu também tava confuso nessa

<_edEr> hehe

<_edEr> bacana o “atalho”

<_edEr> hehe

<AlissonB> FabioOlive, quem convencionou que o int é 4 bytes e o char é 1?

<FabioOlive> a história da computação ;)

<FabioOlive> em computadores de 16 bits, o int é de 16 bits

<FabioOlive> em arduinos, por exemplo, que são processadores de 8 bits, o int é 16 bits

<AlissonB> como assim? processador de 8 bits e o int é 16?

<FabioOlive> é que “int” é uma coisa do C, saca?

<AlissonB> humm

<AlissonB> mas as variáveis gerais em outras linguagens não funcionam da mesma forma?

<AlissonB> não alocam o mesmo espaço?

<FabioOlive> então se convencionou que o int seria sempre 16 ou 32 bits

<FabioOlive> o char é sempre 8

<FabioOlive> e o long é sempre 32 ou 64

<FabioOlive> AlissonB: depende muito :) um tipo numérico em python não tem um tamanho definido :)

<FabioOlive> ele pode ser astronomicamente grande e ocupar metade da tua memória :)

<FabioOlive> claro que aí não tem como usar operações nativas do processador nesses números em python

<FabioOlive> e o python precisa implementar tipos e operações mais abstratas, baseadas nas operações nativas, para fazer de conta que números muito grandes existem :)

<AlissonB> que doidera

<AlissonB> na tua palestra do boot, tu falou que o Arduino utiliza aquele outro conceito de arquitetura, acho que é Harvard o nome, ou algo assim

<AlissonB> não to lembrado

<AlissonB> não é o Von Neumann

<AlissonB> daí ele executa direto no processador?

<FabioOlive> não

<FabioOlive> AlissonB: o processador executa a memória, isso é assim pra todos os processadores

<FabioOlive> a arquitetura harvard separa o que é memória de programa do que é memória de dados

<AlissonB> ah tá

<marlon> Fabio, para os numeros mega grandes em python que fica responsavel por eles?

<AlissonB> boa marlon!

<FabioOlive> o python simula as operações, quebrando-as em 32 em 32 bits :)

<FabioOlive> tipo, pra somar dois números que estejam ocupando 128 bits ele quebra em 4 somas de 32, fazendo “vai um” entre elas :)

<marlon> Hmmm legal :D

<marlon> o python usa alguma maquina virtual ?

<marlon> Assim como o java

<FabioOlive> sim, usa uma VM de python :)

<FabioOlive> parecido com java :) a idéia do java não era nada nova :)

<FabioOlive> ele só tinha uma grande empresa por trás pra fazer marketing :)