(Resolvido) Exibição de valores com printf

[Rogério Shoiti]

Pessoal, estou dando início aos estudos de C/C++ e lendo o exemplo do livro sobre como exibir valores do tipo unsigned int e long int através da função printf, tentei executá-los conforme indicava.

Utilizei o compliador Dev-C++. Ele compilou, mas quando a janela do executável abriu, o resultado estava diferente do livro e também não tinha lógica.

O valor que surgiu na string "Exibe valor como int" ficou igual a string "Exibe valor como unsigned" no valor de 42000

include <stdio.h>

void main (void)

{    
     unsigned int valor = 42000;
     printf ("Exibe valor como unsigned = %u\n", valor);
     printf ("Exibe valor como int = %d\n", valor);
     system ("pause");
     return (0);
}

No livro diz que o valor exibido utilizando %d, a função printf entenderia como se fosse um valor int, seria -23536 e o valor de %u seria 42000. Também não entendi como esse valor -23536 surgiu. E outra: O valor máximo aceito pela variável unsigned int deve ser igual a 16 bits (65535). Porém, eu posso colocar um valor bem maior que isso, tipo 100000 que o número inteiro não estoura!! Se eu adiciono a variável short junto a unsigned int aí sim o valor de %u vai até 65535 e se extrapola, tipo 65536 ele vira 1. Mas até o valor 65535, %d continua igual ao valor de %u. O mesmo problema ocorre em:

#include <stdio.h>

void main (void)

{    
     long int valor = 1000000;
     printf ("Exibe valor como long = %ld\n", valor);
     printf ("Exibe valor como int = %d\n", valor);
     system ("pause");
     return (0);
}

O valor de %d deveria ser 16960, mas ele aparece como 1000000

Muito obrigado aos que me ajudarem

Editado Agosto 28, 2009 por Rogério Shoiti

[Mnemonic]

O valor que surgiu na string "Exibe valor como int" ficou igual a string "Exibe valor como unsigned" no valor de 42000

include <stdio.h>

void main (void)

{    
     unsigned int valor = 42000;
     printf ("Exibe valor como unsigned = %u\n", valor);
     printf ("Exibe valor como int = %d\n", valor);
     system ("pause");
     return (0);
}

Antes de mais nada queria só te alertar pro fato de que essa função não tá correta. No início tem "void main" e no final um "return 0". Apesar dela compilar normalmente na maioria dos compiladores, o correto seria usar "int main" e "return 0".

Se no livro está exatamente assim, eu te aconselho a buscar um segundo livro pra servir de base, na boa.

No livro diz que o valor exibido utilizando %d, a função printf entenderia como se fosse um valor int, seria -23536 e o valor de %u seria 42000.

Também não entendi como esse valor -23536 surgiu.

O que o livro tentou dizer aqui é o seguinte, uma variável do tipo INT teria 16 bits, 16 bits equivalem a 16 combinações de 0 e 1, então você poderia ter um valor mínimo de 00000000000000 (que equivale a 0 mesmo) e 1111111111111111 (que equivale a 65535 em binário).

Só que como você tem valores negativos e positivos, então essa quantidade de valores cai pra menos da metade num int normal (sem ser "unsigned"), porque o primeiro BIT é responsável pra dizer se o número é positivo ou negativo.

Ou seja:

[0] 111111111111111 > os 15 um's que sobraram tem um valor máximo de 32767

[1] 111111111111111 > -32678

Pegando o valor 42000 e transformando pra binario:

1010010000010000 -> 42000

1111111111111111 -> 65535

-1010010000010000 -> 42000

------------------------

= 0101101111101111 -> 23535 , (valor unsigned, -1 porque o compilador conta o zero)

Ok, isso tudo é o que deveria acontecer normalmente, mas o que acontece é que os compiladores mais atuais não usam mais 16 bits pra um inteiro, e sim 32 bits (dependendo do compilador), então esses valores do livro se tornaram obsoletos (o que é muito fácil, pois a gente sabe que os computadores evoluem muito rápido).

32 bits:

4294967295 -> 11111111111111111111111111111111

Pra pegar todos esses valores, você pode usar a calculadora do windows que faz conversão de bin pra dec.

E outra: O valor máximo aceito pela variável unsigned int deve ser igual a 16 bits (65535). Porém, eu posso colocar um valor bem maior que isso, tipo 100000 que o número inteiro não estoura!! Se eu adiciono a variável short junto a unsigned int aí sim o valor de %u vai até 65535 e se extrapola, tipo 65536 ele vira 1. Mas até o valor 65535, %d continua igual ao valor de %u.

Então, como eu disse antes, não existe um padrão pra quantidade de bits usados nas variáveis.

Pelos resultados que você teve aí, acredito que o seu compilador usa esses valores:

short int - 16 bits

int - 32 bits

long int - 64 bits

Mas isso não é um padrão. Cada compilador implementa isso de um jeito, e pode ser que daqui a um ano quando você baixar outra versão do compilador, esses valores sejam diferentes.

No gcc eu acredito que haja algum controle do próprio compilador pra impedir que os valores extrapolem (o que é uma coisa boa).

Editado Agosto 28, 2009 por Mnemonic

[Rogério Shoiti]

Olá Mnemonic... obrigado por responder :D

Essa parte eu não estou conseguindo entender:

Ou seja:

[0]111111111111111 > os 15 um's que sobraram tem um valor máximo de 32767

[1] 111111111111111 > -32678

Se 0111111111111111 = 32767, então 1111111111111111 = 65535.

Mas se o 1° bit da esquerda p/ direita é o bit mais significativo e é ele que indica se o valor é + ou - , então o valor não seria igual a -32767 ao invés de -32768 ?

Obrigado :lol:

[Mnemonic]

É que dependendo da arquitetura, existe uma coisa meio esotérica, que é o seguinte... seguindo a lógica do bit que indica o sinal de positivo e negativo, você teria então +0 e -0:

100000000000000

000000000000000

Então, se eu não me engano esse valor negativo é usado como um valor a mais, já que não faz sentido ter zero positivo e negativo.

(Espero que eu não esteja falando nenhuma besteira, faz muito tempo que vi isso).

Edit:

Agora que eu vi, no exemplo de cima [1] seguido de 15 zeros eu errei o valor.

Editado Agosto 29, 2009 por Mnemonic

[Rogério Shoiti]

Agora minha questão ficou esclarecida Mnemonic.

Muito obrigado