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?

13 de fevereiro de 2014 às 08:52

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

21 de fevereiro de 2014 às 17:29

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

7 de março de 2014 às 16:06

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.

8 de março de 2014 às 15:29

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));
}

2 de abril de 2014 às 05:21

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

26 de maio de 2014 às 17:10

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

26 de maio de 2014 às 19:01

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.

16 de julho de 2014 às 06:38

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

18 de julho de 2014 às 10:25

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

11 de agosto de 2014 às 11:25

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??

13 de agosto de 2014 às 02:50

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.

28 de agosto de 2014 às 08:58

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 ));
}

29 de outubro de 2014 às 16:06

#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?

25 de novembro de 2014 às 04:11

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));

}

26 de novembro de 2014 às 05:10

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;
}

30 de dezembro de 2014 às 19:17

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ê

4 de janeiro de 2015 às 17:35

Estou aprendendo mais aqui do que no Brava Cursos.

4 de março de 2015 às 15:04

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.

2 de abril de 2015 às 05:52

#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

*/

29 de abril de 2015 às 16:18

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);


}

7 de setembro de 2015 às 17:31

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));
}

7 de novembro de 2015 às 16:55

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

10 de novembro de 2015 às 18:45

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.

27 de março de 2016 às 11:55

#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));
}

18 de abril de 2016 às 13:11

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.

1 de junho de 2016 às 16:05

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.

3 de dezembro de 2016 às 09:13

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?

7 de fevereiro de 2017 às 09:15

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 :)

6 de março de 2017 às 13:39

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);
}

15 de maio de 2017 às 21:23

# 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));


}

7 de setembro de 2017 às 21:41

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!!!

9 de setembro de 2017 às 06:15

#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

22 de fevereiro de 2018 às 11:11

#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!!!

25 de fevereiro de 2018 às 12:11

#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;
}

5 de julho de 2018 às 08:25

Cara esse site é muito bom. Indico, compartilho. Está me ajudando muito.

9 de setembro de 2018 às 19:55

#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;


}

22 de outubro de 2018 às 17:24

#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;


}

22 de outubro de 2018 às 17:25

#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;
}

11 de dezembro de 2018 às 08:25

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!

23 de janeiro de 2019 às 03:43

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).

19 de maio de 2019 às 08:10

#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));
}

16 de setembro de 2019 às 17:01

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++

20 de fevereiro de 2021 às 06:19

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));

}

31 de janeiro de 2022 às 07:05