Modificadores do tipo inteiro - short, long, signed e unsigned

Trabalhar com a linguagem  de programação C é gratificante devido ao poder e liberdade que você tem, já que podemos atuar no 'talo' do sistema, inclusive selecionando espaços de memória.

Porém, isso tem um custo: estudo e cuidados adicionais, em relação a grande maioria das outras linguagens de programação.

Por exemplo, o tamanho que um variável do tipo inteira (int) pode ocupar em diferentes computadores e sistemas. Falaremos mais detalhes sobre essas variações neste artigo de nossa apostila de C.

O tamanho que cada variável em C pode ocupar em memória

Vimos que uma variável do tipo int (inteira) em C, geralmente ocupa 2 ou 4 bytes na memória de seu computador.
Essa diferença, à priori, pode parecer insignificante. Mas é porque estamos no início de nossos estudos na linguagem C, e por hora, nossos códigos e programas são bem simples e pequenos.

Mas a maior parte dos sistemas operacionais, como o Linux e o Windows, são feitos em C e aí essa diferença pode se tornar um problema, principalmente por questões de portabilidade.
Ou seja, você pode compilar/rodar seu código em C no seu computador e obter um resultado, mas pode rodar em outro computador ou sistema (de diferentes configurações) e obter resultados totalmente diferentes (e erros, as vezes).

O grande diferencial da linguagem de programação Java é que ela não roda em sua máquina, e sim em uma máquina virtual.
Essa máquina virtual (JVM - Java Virtual Machine) é simulada em todos os dispositivos, portanto, o Java roda da mesma maneira em todos os sistemas (porém, geralmente suas aplicações são bem mais lentas que aquelas feitas em C ou C++, por exemplo).
Para saber mais sobre Java, oferecemos um curso completo de Java no site Java Progressivo: http://www.javaprogressivo.net/

Se quiser saber quanto vale o valor do int, ou de qualquer outra variável, use a função 'sizeof( tipo )', e troque 'tipo' por um tipo de variável.

O exemplo a seguir mostra como descobrir o valor da variável int em C, usando a função sizeof:

#include <stdio.h>

int main()
{
    printf("O tamanho do inteiro em meu computador: %d bytes", sizeof(int));
}


Tendo um maior controle sobre o tamanho dos inteiros - short e long

Vamos apresentar agora dois modificadores do tipo inteiro em C: short e long, ele alteram o tamanho de bytes do inteiro.
A diferença entre os inteiros e modificadores está na faixa de valores armazenadas.

Um inteiro de 1 byte (char) armazena do número -128 a +127
Um inteiro de 2 bytes armazena do número -32 768 a +32 767
Um inteiro de 4 bytes armazena do número -2 147 483 648 a +2 147 483 647
Um inteiro de 8 bytes armazena do número -9 223 372 036 854 775 808 a +9 223 372 036 854 775 807

'short' em inglês, significa curto e 'long', longo.
Colocando uma dessas palavras antes da 'int', você definirá um tamanho e uma faixa de valores para suas variáveis.

Por exemplo, se criar a variável inteira 'numero' como short, deverá fazer:
short int numero;

De modo análogo para uma variável com o modificador 'long':
long int numero;

Para saber o tamanho de bytes de seu sistema, use novamente a função sizeof:

#include <stdio.h>

int main()
{
    printf("int : %d bytes\n", sizeof( int ) );
    printf("short int: %d bytes\n", sizeof( short ) );
    printf("long int: %d bytes\n", sizeof( long ) );
}


Controlando a faixa de valores dos inteiros através do sinal: signed e unsigned

Todos nós sabemos que os números, como os inteiros, podem assumir tanto valores negativos como positivos.
Porém, muitas vezes, valores negativos (ou positivos) podem ser inúteis, chegando até a atrapalhar em termos de computação.

Por exemplo, o tamanho de memória é sempre positivo, não existe um bloco de -2 bytes em sua máquina.
Então, para declarar que um número seja apenas positivo (incluindo o 0), usamos o modificador unsigned:
unsigned int teste;

Analogamente para especificar que o inteiro possui valores positivos e negativos:
signed int teste;

Em C, por padrão, ao declararmos uma variável do tipo int, ele será automaticamente do tipo signed.
Portanto, a declaração passada é inútil, serve apenas para fins didáticos.

Caso queiramos apenas números positivos, a faixa de valores negativos que apresentamos é inútil e podemos desconsiderar ela, aumentando a faixa de valores positivos.
Então, ao declararmos inteiros com o modificador unsigned, as faixas de valores passam a ser:
Um inteiro de 1 byte (char) armazena do número 0 a +255
Um inteiro de 2 bytes armazena do número 0 a +65 535
Um inteiro de 4 bytes armazena do número 0 a +4 294 967 295
Um inteiro de 8 bytes armazena do número 0 a +18 446 744 073 709 551 615


Quando usar short, long, signed e unsigned

O curso C Progressivo visa ensinar o básico, então, não será necessário usarmos esses modificadores ao longo de nossa apostila online.

No futuro, quando você for um programador profissional, será um ótimo e diferenciado costume usar esses modificadores.

Quando usar o short int em C
Você deverá usar o short quando quiser armazenar, sempre, valores pequenos.
Por exemplo, suponha que você vá fazer um banco de dados para o Governo Federal, onde terá que criar milhões de cadastros.
Para armazenar idades, usar short int. Ora, valores inteiros de idades são pequenos e raramente passam do 100.
Então não desperdice memória à toa, use short!

Quando usar o long int em C

O long é bastante usado para cálculos de cunho acadêmico, como científico e estatístico.
É comum também usarmos o long int para armazenar números como RG e CPF, que são compostos de vários dígitos.




Quando usar unsigned int em C

Você pode usar o unsigned para se certificar que essa variável inteira nunca irá receber um valor negativo, como para armazenar dados de memória, idade, o life de um jogo etc.


Para saber mais sobre esse limites e padrões da linguagem C, acesse:
http://en.wikipedia.org/wiki/Limits.h


Exercício:

Crie um programa em C que mostre o tamanho das seguintes variáveis em seu computador:
  • int
  • short int
  • long int
  • signed int
  • unsigned int
  • short signed int
  • short unsigned int
  • long signed int
  • long unsigned int

23 comentários:

Tiago Antonio da Silva disse...

Olá, parabéns pelo site, muito bem explicado. Tenho as seguintes dúvidas. Usando a função sizeof(), int e long int apresentam 4 bytes, mas quando uso o modificador long long, o num de bytes dobra. Então nesse caso, o modificados long é irrelevante?
E em relação ao modificador unsigned, o usei num programa e mesmo assim a variável aceitou valor negativo:
#include

int main(void)
{ unsigned int x;
printf("Long int possui %d bytes e int possui %d bytes \nenquanto long long int possui %d.\n\n", sizeof(long int),sizeof(int),sizeof(long long int));
printf("Digite um numero:\n");
scanf("%d",&x);
printf("O numero que vc digitou eh: %d\n", x);
return(0);
}
Pq? Eu usei o modificador errado?

Anônimo disse...

eu fiz o exercicio utilizando somente um print demorou um pouco
mas e testando que se aprende

fiz desta maneira

#include

int main()
{
printf("int : %d bytes\nshort int: %d bytes\nlong int: %d bytes\nsigned int: %d bytes\nunsigned int: %d bytes\nshort signed int: %d bytes\nshort unsigned int: %d bytes\nlong signed int: %d bytes\nlong unsigned int: %d bytes"
, sizeof( int ),sizeof( short ), sizeof( long ), sizeof( signed ), sizeof( unsigned ), sizeof( short ), sizeof( short unsigned ), sizeof( long signed ), sizeof( long unsigned ));

}

ficou ate grande // mas testei da outra forma do exemplo tambem
eu so queria saber se era possivel fazer com um unico print

Anônimo disse...

Eu conseguir fazer o exercicio sem olhar mas deu dois erro mas eu corrigi. e funcionou !!! perfeitamente.

Anônimo disse...

Boa noite,
Primeiro parabéns pela iniciativa de disponibilizar o curso de 'C', porém estou tendo problemas com o comando 'sizeof()', quando mando executar o código o codeblocks me retorna esse erro:
aviso: formato ‘%d’ espera argumento do tipo ‘int’, porém o argumento 2 possui tipo ‘long unsigned int’ [-Wformat]|

queria saber se tá acontecendo com mais alguém, eu já fiz e refiz o programa, inclusive testei copiar e colar o código disponível.

Desde já agradeço.

Luciano.

Juliana Moraes Lacerda disse...

Eu fiz do jeito básico e deu certinho:

# include
int main ()
{
printf("int: %d bytes\n", sizeof(int));
printf("short int: %d bytes\n", sizeof(short int));
printf("long int: %d bytes\n", sizeof (long int));
printf("unsigned long int: %d bytes\n", sizeof (unsigned long int));
printf("signed long int: %d bytes\n", sizeof (signed long int));
printf("unsigned short int: %d bytes\n", sizeof(unsigned short int));
printf("signed short int: %d bytes\n", sizeof(signed short int));
printf("unsigned int: %d bytes\n", sizeof(unsigned int));
printf("signed int: %d bytes\n", sizeof(signed int));
}

Anônimo disse...

Eu gostaria de um programa que armazenasse 13 números inteiros.
Ex: 1234567890123

#Me_Ajude
Pois é para um trabalho usando o numero do código de barras de um produto que são 13 digitos

Enviar para: waldebergue@hotmail.com

Apostila C Progressivo disse...

Anônimo, nesse caso pode ser mais interessante você usar um vetor de inteiros.

Monarquista Convicto disse...

Parabéns pela iniciativa! eu que me considero um completo analfabeto digital estou aprendendo até com uma certa facilidade graças à didática que vocês utilizam. Muito obrigado mesmo.

Willian Silva disse...

quando coloquei unsigned int x; a váriável aceitou números negativos. Neste caso unsigned é irrelevante.

Brittivaldo disse...

a padrão unsigned não afetou em nada as minhas variáveis.
Obrigado pelas aulas.

Anônimo disse...

os valores era para aparecer assim
valor de int 4
,short int e 2,
long int e 4,
signed int e 4,
unsigned int e 4
short signed int e 2,
short unsigned int e 2,
long signed int e 4,
long unsigned int e 4
Process returned 89 (0x59) execution time : 0.467 s
Press any key to continue.

ou os numeros tinham que ser maior??

Brittivaldo disse...

Continuei os testes: E o que observei é que unsigned não afetou em nada as variáveis int no sistemas 64bits cujo valor em bits de int é 32.
Para tanto declarei assim:
unsigned short int iValor;
Desta declaração o int reduziu a 16 bits e não aceitou valores negativo.
Ocorrendo como na apostila

Parabéns pela iniciativa, pela apostila gratuito, pela excelente qualidade.

Mac Leuds disse...

olha o meu ai

include

int main()
{
printf (" int : %d bytes\n", sizeof ( int ));
printf (" short int : %d bytes\n", sizeof ( short int ));
printf (" long int : %d bytes\n", sizeof ( long int ));
printf (" signed in : %d bytes\n", sizeof ( signed int ));
printf (" unsigned int : %d bytes\n", sizeof ( unsigned int ));
printf (" short signed int : %d bytes\n", sizeof ( short signed int ));
printf (" short unsigned int : %d bytes\n", sizeof ( short unsigned int ));
printf (" long signed int : %d bytes\n", sizeof ( long signed int ));
printf (" long unsigned int : %d bytes\n", sizeof ( long unsigned int ));
}

Anônimo disse...

#include

int main()
{
printf("int %d\n", sizeof(int));
printf("short %d\n", sizeof(short));
printf("long %d\n", sizeof(long));
printf("signed %d\n", sizeof(signed));
printf("unsigned %d\n", sizeof(unsigned));
printf("short signed %d\n", sizeof(short signed));
printf("short unsigned %d\n", sizeof(short unsigned));
printf("long signed %d\n", sizeof(long signed));
printf("long unsigned %d\n", sizeof(long unsigned));
}

Aqui funcionou assim porque alguns colocam int após short, long, etc. É necessário?

Anônimo disse...

Olá... eu fiz dessa maneira e funcionou também !

#include

int main()
{
short int n1;
long int n2;

printf("tamanho do inteiro short em meu computador: %d bytes \n", sizeof(n1));
printf("tamanho do inteiro long em meu computador: %d bytes \n", sizeof(n2));

}

Anônimo disse...

Também é possível utilizar a função printf() apenas uma vez, evitando assim ter que repeti-la várias vezes (apesar de ser um exercício, DRY, KISS):

int main(void)
{
printf("int: %d \n"
"short int: %d \n"
"long int: %d \n"
"signed int: %d \n"
"unsigned int: %d \n"
"short signed int: %d \n"
"short unsigned int: %d \n"
"long signed int: %d \n"
"long unsigned int: %d \n",
sizeof(int),
sizeof(short int),
sizeof(long int),
sizeof(signed int),
sizeof(unsigned int),
sizeof(short signed int),
sizeof(short unsigned int),
sizeof(long signed int),
sizeof(long signed int)
);

return 0;
}

Kauê disse...

1 - Está sendo irrelevante pra mim aqui colocar long int, unsigned int ou unsigned long int, o compilador está alocando 4 bytes de memória apenas, números negativos e positivos. atribui 4000000000 (4 bilhões) em long int e unsigned int mas retorna valores malucos, que são resíduos da memória resultantes de overflow, teoricamente era para armazenar algo até em torno de 4,3 bilhões positivos para unsigned int e até 18 446 744 073 709 551 615 para long int.
2 - Unsigned a principio era para iniciar valores a partir do zero, porém também está falhando ao ser usado com int, funciona apenas usando unsigned short int.
3 - Estou utilizando o Visual Studio (a faculdade me oferece gratuitamente).
4 - Pesquisando no Google, achei algumas coisas a respeito e segundo o que li, e depois testei na IDE é claro, o int usado em conjunto com long e unsigned compilam, porém não tem efeito algum, o int continua alocando 4 bytes e com valores negativos e positivos. Testei o unsigned short int, compilou, rodou o programa, aceitou apenas números positivos, mas ao fechar o programa dá erro, (Run-Time Check Failure #2 - Stack around the variable 'num2' was corrupted.), com as opções "Break" ou "Continue". ?? sei lá, malucão.
6 - Presumo que houve algum update na linguagem e agora para utilizar número grandes devemos usar somente float e double. Me corrijam por favor se eu estiver errado e falando besteira :P.

Kauê

Anônimo disse...

Estou aprendendo mais aqui do que no Brava Cursos.

Douglas Martins Dávoli disse...

nossa minha professora teria um treco vendo alguns códigos postados aqui parece um espaguete, então a organização do código e parte fundamental para você corrigir erros e ate modificar algo, soltar espaços entre linhas e não ficar com preguiça de escrever.E só isso, aqui no cprogressivo e tudo bem explicado só estou revisando algumas coisas o site e muito bom só de dicas de organização desde já para que quem esta aprendendo aqui não se perder nos códigos mais pra frente.

Rafael Fontoura disse...

#include
//como ficou o resultado do meu exercício

int main()
{


int a;
short int b;
long int c;
signed int d;
unsigned int e;
short signed int f;
short unsigned int g;
long signed int h;
long unsigned int i;

printf(" sizeof int = %d \n sizeof short int = %d \n sizeof long int = %d \n sizeof signed int = %d \n sizeof unsigned int = %d \n sizeof short signed int = %d \n sizeof short unsigned int = %d \n sizeof long signed int = %d \n sizeof long unsigned int = %d \n", sizeof(a), sizeof(b), sizeof(c), sizeof(d), sizeof(e), sizeof(f), sizeof(g), sizeof(h), sizeof(i));

}
#fim exercicio

/* resultado:

sizeof int = 4
sizeof short int = 2
sizeof long int = 4
sizeof signed int = 4
sizeof unsigned int = 4
sizeof short signed int = 2
sizeof short unsigned int = 2
sizeof long signed int = 4
sizeof long unsigned int = 4

*/

Ramon Pires disse...

1 Descri¸c˜ao
Implemente um programa em C que verifique e escreva na tela o tamanho de cada um dos tipos
de dados da linguagem C, vistos em aula. Seu programa devera imprimir a sequencia de 10 numeros, sendo cada um o tamanho de um tipo na ordem abaixo:

• char
• unsigned int
• short int
• int
• long int
• unsigned long int
• long long int
• float
• double
• long double

2 Instrucoes Complementares

• Pesquise sobre o operador sizeof.
• Cada numero dever´a ser impresso em uma linha, utilize um \n em cada comando printf.
• Submeta o arquivo .c com seu codigo no http://run.codes

3 Exemplos de Entrada e Saıda

Neste exercıcio n˜ao ser˜ao exibidos exemplos de entrada e sa´ıda, uma vez que n˜ao existe entrada
de teclado e a saıda ´e um bloco padrao.

técnico em informatica disse...

#include

int main()
{
printf("int: %d bayts\n",sizeof(int ));
printf(" short: %d bayts\n",sizeof(short int));
printf("long: %d bayts\n",sizeof(long int));
printf("signed:%d bayts\n ",sizeof (signed int));
printf("unsigned: %d bayts \n",sizeof(unsigned int));
printf(" short signed : %d bayts \n",sizeof(short signed int));
printf(" short unsigned : %d bayts \n",sizeof (short unsigned int));
printf("long signed : %d bayts \n",sizeof(long signed int));
printf("long unsigned: %d bayts \n ",sizeof(long unsigned int));
}

vinicius goulart disse...

oi o código do programa

#include

int main()
{
printf("Este programa mosta agumas coisa do meu pc\n");
printf("int : %d bytes\n", sizeof( int ) );
printf("short int: %d bytes\n", sizeof ( short ) );
printf("long int: %d bytes\n", sizeof ( long ) );
printf("signed int: %d bytes\n", sizeof ( signed ) );
printf("unsigned int: %d bytes\n", sizeof ( unsigned ) );
printf(" short signed int: %d bytes\n", sizeof ( short signed ) );
printf("short unsigned int: %d bytes\n", sizeof ( short unsigned ) );
printf("long signed int: %d bytes\n", sizeof ( long signed ) );
printf("long unsigned int: %d bytes\n", sizeof ( long unsigned ) );
}

o resultado do programa

Este programa mosta agumas coisa do meu pc
int : 4 bytes
short int: 2 bytes
long int: 4 bytes
signed int: 4 bytes
unsigned int: 4 bytes
short signed int: 2 bytes
short unsigned int: 2 bytes
long signed int: 4 bytes
long unsigned int: 4 bytes

Process returned 27 (0x1B) execution time : 0.678 s
Press any key to continue.

Gostou desse tutorial de C?
Sabia que o acervo do portal C Progressivo é o mesmo, ou maior que, de um livro ou curso presencial?
E o melhor: totalmente gratuito.

Mas para nosso projeto se manter é preciso divulgação.
Para isso, basta curtir nossa página no Facebook e/ou clicar no botão +1 do Google.
Contamos e precisamos de seu apoio.