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.
- Leia esse conteúdo Offline: Apostila C Progressivo
O tamanho que cada variável em C pode ocupar em memória
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
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
44 comentários:
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?
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
Eu conseguir fazer o exercicio sem olhar mas deu dois erro mas eu corrigi. e funcionou !!! perfeitamente.
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.
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));
}
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
Anônimo, nesse caso pode ser mais interessante você usar um vetor de inteiros.
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.
quando coloquei unsigned int x; a váriável aceitou números negativos. Neste caso unsigned é irrelevante.
a padrão unsigned não afetou em nada as minhas variáveis.
Obrigado pelas aulas.
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??
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.
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 ));
}
#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?
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));
}
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;
}
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ê
Estou aprendendo mais aqui do que no Brava Cursos.
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.
#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
*/
Eu também fiz o simples e deu certo , mas o meu codeblocks dá erro quando faço esse algoritmo:
#include
int main () {
int x;
scanf(x);
printf("seu número é %d \n", x);
}
Para quem teve o erro abaixo:
aviso: formato ‘%d’ espera argumento do tipo ‘int’, porém o argumento 2 possui tipo ‘long unsigned int’ [-Wformat]|
Troque '%d' por '%ld'
No código:
#include
int main()
{
printf("O tamanho do inteiro em meu computador: %ld bytes", sizeof(int));
}
a diferença prática de signed e unsigned é o range de cada tipo
como no signed int é reservado o bit mais significativo para guardar o sinal do número, voce possui 31 bits para o número, dando um range de -2^31 até 2^31-1
já para o unsigned int, voce tem o range absoluto maior variando de 0 até 2^32-1
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.
#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));
}
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.
Pelo que notei, usar um valor negativo em uma variável "unsigned" não causa erros no programa. Usei em um programa a variável " unsigned short int d " e quando pus um valor -1 ele exibiu o resultado esperado para 1 e o mesmo aconteceu com outros valores. Como por exemplo:
#include
int main()
{
unsigned short int numero;
scanf("%d", &numero);
printf("o numero digitado é: %d", numero);
if(numero == 1){
printf("Funciona!\n");
}
else{
printf("Não funciona!\n");
}
return 0;
}
Input: -1
Output: Funciona!
Foi isso o que aconteceu com o programa que criei. Espero ter ajudado.
fiz assim
printf("int: %d bytes \n", sizeof (int));
printf("short: %d bytes \n", sizeof (short));
printf("long: %d bytes \n", sizeof (long));
printf("%d \n", sizeof 'unsigned');
printf("%d \n", sizeof 'signed');
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 int: %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));
}
tá certo?
Pra quem esta com problemas no unsigned int, basta fazer:
#include
int main()
{
unsigned int n;
printf("informe um numero: \n");
scanf("%u", &n);
printf("Digitado:%u\n",n);
return 0;
}
O codigo irar retornar um valor aleatorio caso seja um numero negativo, da pra fazer um IF com isso :)
como ficaria esse??
Desenvolver um programa que a partir de um número dado, determine o tipo da variável numérica inteira mais adequado. Leia-se por mais adequado o tipo de variável que desperdiça menos espaço de memória e possibilita o armazenamento do número em questão. Os tipos a serem consideradors são char, short, int e long long int (com e sem o modificador de tipo unsigned).
Exemplo:
#include
#include
int main(void) {
long long int num;
///2(0 ou 1) ^ qtde de bits
///2^8 = 256 (combinações possíveis)
///Numeros positivos: (0..255)
///Numeros positivos e negativos: (-128..-1) e (0..127)
///
///Exemplo: 2^7 => pow(2,7) => 128
printf("\nchar..: tamanho %d bits - Limites: %.0f a %.0f",
sizeof(char)*8,
pow(2,sizeof(char)*8-1)*-1,
pow(2,sizeof(char)*8-1)-1);
printf("\nint...: tamanho %d bits - Limites: %.0f a %.0f",
sizeof(int)*8,
pow(2,sizeof(int)*8-1)*-1,
pow(2,sizeof(int)*8-1)-1);
printf("\n\nNumero: ");
scanf("%lld",&num);
///Se numero pode ser armazendo em um char
if((num>=pow(2,sizeof(char)*8-1)*-1)&&
(num<=pow(2,sizeof(char)*8-1)-1))
printf("E possivel armazenar o numero %lld em um char\n",num);
else
printf("NAO e possível armazenar o numero %lld em um char\n",num);
}
# include
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));
printf("signed int : %d bytes \n", sizeof(signed));
printf("unsigned int : %d bytes \n", sizeof(unsigned));
printf("short signed int : %d \n", sizeof(short signed));
printf("short unsigned int: %d \n", sizeof(short unsigned));
printf("long signed int: %d \n", sizeof(long signed));
printf("long unsigned int : %d \n", sizeof(long unsigned));
}
Eu estava lendo o codigo dos programas postados nos comentários e reparei que a maioria nao usa o dps do #include, tentei na minha maquina e deu erro
Eis omeu código:
#include
int main()
{
int;
short int;
long int;
signed int;
unsigned int;
short signed int;
short unsigned int;
long signed int;
long unsigned int;
printf("int:\n\n %d\n\n", sizeof(int));
printf("short:\n\n %d \n\n", sizeof(short int));
printf("long int:\n\n %d \n\n", sizeof(long int));
printf("signed int:\n\n %d \n\n", sizeof(signed int));
printf("unsigned int:\n\n %d \n\n", sizeof(unsigned int));
printf("short signed int:\n\n %d \n\n", sizeof(short signed int));
printf("long signed int:\n\n %d \n\n", sizeof(long signed int));
printf("short unsigned int:\n\n %d \n\n", sizeof(short unsigned int));
printf("long unsigned int:\n\n %d \n\n", sizeof(long unsigned int));
}
PS: Reparei tamebem que usei palavras a mais sendo q eu podia ter abreviado muita coisa xD
Ótimo site!!!
#include
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));
printf("signed int: %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));
Resultado:
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
#include
int main(void){
//Exercicio.
printf("int: %d bytes.\n"
"short int: %d bytes.\n"
"long int: %d bytes.\n"
"signed int: %d bytes.\n"
"unsigned int: %d bytes.\n"
"short signed int: %d bytes.\n"
"short unsigned int: %d bytes.\n"
"long signed int: %d bytes.\n"
"long unsigned int: %d bytes.\n"
"long long int: %d bytes.",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 unsigned int), sizeof(long long int));
return 0;#include
int main(void){
//Exercicio.
printf("int: %d bytes.\n"
"short int: %d bytes.\n"
"long int: %d bytes.\n"
"signed int: %d bytes.\n"
"unsigned int: %d bytes.\n"
"short signed int: %d bytes.\n"
"short unsigned int: %d bytes.\n"
"long signed int: %d bytes.\n"
"long unsigned int: %d bytes.\n"
"long long int: %d bytes.",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 unsigned int), sizeof(long long int));
return 0;
}
Muito bom o site!!!
#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 int..: %d bytes \n", sizeof(signed int));
printf("unsigned int: %d bytes \n", sizeof(unsigned int));
printf("-----------------------------------\n");
printf("short signed.....: %d bytes \n", sizeof(short signed int));
printf("short unsigned...: %d bytes \n", sizeof(short unsigned int));
printf("long signed......: %d bytes \n", sizeof(long signed int));
printf("long unsigned....: %d bytes \n", sizeof(long unsigned int));
return 0;
}
Cara esse site é muito bom. Indico, compartilho. Está me ajudando muito.
#include
#include
#include
#include
// Elabore um programa que pede seu nome, endereço, CEP e telefone. Ele deve imprirmir seu nome completo na primeira linha, seu endereço na segunda, e o CEP e telefone na terceira
int main (){
setlocale(LC_ALL, "Portuguese");
char nome[100];
char sobrenome [100];
char endereco[50];
int cep[20],telefone[11];
printf("Digite Seu Nome: ");
scanf(" %s %s",&nome,&sobrenome);
printf("Digite Seu Endereço: ");
scanf("%s",&endereco);
printf(" Digite Seu Cep: ");
scanf("%d",&cep);
printf("Digite Seu Telefone:");
scanf("%d",&telefone);
printf("\n Nome:%s %s\n",nome,sobrenome);
printf(" Endereço: %s\n",endereco);
printf(" CEP: %d Telefone: %d",cep,telefone);
getch();
return 0;
}
#include
#include
#include
#include
// Elabore um programa que pede seu nome, endereço, CEP e telefone. Ele deve imprirmir seu nome completo na primeira linha, seu endereço na segunda, e o CEP e telefone na terceira
int main (){
setlocale(LC_ALL, "Portuguese");
char nome[100];
char sobrenome [100];
char endereco[50];
int cep[20],telefone[11];
printf("Digite Seu Nome: ");
scanf(" %s %s",&nome,&sobrenome);
printf("Digite Seu Endereço: ");
scanf("%s",&endereco);
printf(" Digite Seu Cep: ");
scanf("%d",&cep);
printf("Digite Seu Telefone:");
scanf("%d",&telefone);
printf("\n Nome:%s %s\n",nome,sobrenome);
printf(" Endereço: %s\n",endereco);
printf(" CEP: %d Telefone: %d",cep,telefone);
getch();
return 0;
}
#include
int main(void)
{
//Esse codigo serve para mostrar o tamanho de alguns tipos de memoria do meu computador
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));
return 0;
}
Porque o tamamnho da variável long int se mantém em 4 bytes? Não deveria ocupar 8? Obrigada
E Parabéns pelo site!
Boa tarde. Muito obrigado por esse site, ele está me ajudando muito. Mas nn consegui fazer esse exercício. Está aparecendo um aviso e não está rodando:
#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));
}
Eu fiz isso ai, mas quando eu coloco para rodar, a seguinte mensagem aparece para nim:
Goto "Settings->Compiler...->Global compiler settings->GNU GCC Compiler->Toolchain executables" and fix the compiler's setup.
Tried to run compiler executable 'C:\MinGW/bin/mingw32-gcc.exe', but failed!
Skipping...
Nothing to be done (all items are up-to-date).
#include
int main()
{
printf("int possui %d bytes\n" , sizeof (int));
printf("short int possui %d bytes\n" , sizeof (short int));
printf("long int possui %d bytes\n" , sizeof (long int));
printf("signed int possui %d bytes\n" , sizeof (signed int));
printf("unsigned int possui %d bytes\n" , sizeof (unsigned int));
printf("short signed int possui %d bytes\n" , sizeof (short signed int));
printf("short unsigned int possui %d bytes\n" , sizeof (short unsigned int));
printf("long signed int possui %d bytes\n" , sizeof (long signed));
printf("long unsigned int possui %d bytes\n" , sizeof (long unsigned));
}
Olá, testei o modificador unsigned int mas a variável esta recebendo valores negativos. qual a explicação para isso?
Obs: estou usando o DEV C++
Fiz o básico do básico e funcionou
#include
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));
printf("signed int: %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));
}
Postar um comentário