Poniendo a prueba los tipos de variables en c

[ivancea96]

Generalmente: char 1, short 2, int 4, long long 8.

Si quieres verdadera precisión al conocer el tamaño de las variables, tienes:

Código (cpp) [Seleccionar] Expandir

int8_t - uint8_t
int16_t - uint16_t
int32_t - uint32_t
int64_t - uint64_t

Más información de los tipos en: http://www.cplusplus.com/reference/cstdint/

Esos están asegurados de tener ese tamaño. Son todos tipos enteros, con o sin signo (según tengan la 'u' delante)

[Nucleorion]

Joer, no vi el cambio de pagina.

Muchas gracias. Intente usar ese tipo de declaracion pero no me funcionó. Volveré a probar.

El programa quedo asi:

Código (cpp) [Seleccionar] Expandir


#include <stdio.h>
#include <stdlib.h>
#include <limits.h>

void main(){
char tipo_char=1, tipo_char_max=1;                                                  //          -128 a 128
unsigned char tipo_unsigned_char=1, tipo_unsigned_char_max=1;                       //             0 a 256
short int tipo_short_int=1, tipo_short_int_max=1;                                   //        -32768 a 32767
unsigned short int tipo_unsigned_short_int=1, tipo_unsigned_short_int_max=1;        //             0 a 65 535
int tipo_int=1, tipo_int_max=1;                                                     //-2 147 483 648 a 2 147 483 647
long tipo_long=1, tipo_long_max=1;                                                  //-2 147 483 648 a 2 147 483 647
long int tipo_long_int=1, tipo_long_int_max=1;                                      //-2 147 483 648 a 2 147 483 647
unsigned int tipo_unsigned_int=1, tipo_unsigned_int_max=1;                          //             0 a 4 294 967 295
unsigned long tipo_unsigned_long=1, tipo_unsigned_long_max=1;                       //             0 a 4 294 967 295
unsigned long int tipo_unsigned_long_int=1, tipo_unsigned_long_int_max=1;           //             0 a 4 294 967 295
long long tipo_long_long=1, tipo_long_long_max=1;                            // -9223372036854775808 a  9223372036854775807
unsigned long long tipo_unsigned_long_long=1, tipo_unsigned_long_long_max=1; //                    0 a 18 446 744 073 709 551 616

int bits=1;

while(tipo_char>0){
tipo_char_max=tipo_char+(tipo_char-1);
tipo_char=tipo_char*2;
//printf("char admite como maximo: %i \n\n",tipo_char);
bits++;
}
printf("char ................. %ibits de                    %i a                  %i \n\n",bits,tipo_char,tipo_char_max);
bits=0;
while(tipo_unsigned_char>0){
tipo_unsigned_char_max=tipo_unsigned_char+(tipo_unsigned_char-1);
tipo_unsigned_char=tipo_unsigned_char*2;
bits++;
}
printf("unsigned char ........ %ibits .. de                    %i a                  %i \n\n",bits,tipo_unsigned_char,tipo_unsigned_char_max);
bits=1;
while(tipo_short_int>0){
tipo_short_int_max=tipo_short_int+(tipo_short_int-1);
tipo_short_int=tipo_short_int*2;
bits++;
}
printf("short int ........... %ibits .. de               %i a                %i \n\n",bits,tipo_short_int,tipo_short_int_max);
bits=0;
while(tipo_unsigned_short_int>0){
tipo_unsigned_short_int_max=tipo_unsigned_short_int+(tipo_unsigned_short_int-1);
tipo_unsigned_short_int=tipo_unsigned_short_int*2;
//printf("admite como maximo: %i \n\n",tipo_unsigned_short_int);
bits++;
}
printf("unsigned short int .. %ibits .. de                    %i a                %i \n\n",bits,tipo_unsigned_short_int,tipo_unsigned_short_int_max);
bits=1;
while(tipo_int>0){
tipo_int_max=tipo_int+(tipo_int-1);
tipo_int=tipo_int*2;
//printf("admite como maximo: %i \n\n",tipo_long_int);
bits++;
}
printf("int ................. %ibits .. de          %i a           %i \n\n",bits,tipo_int,tipo_int_max);
bits=1;
while(tipo_long>0){
tipo_long_max=tipo_long+(tipo_long-1);
tipo_long=tipo_long*2;
//printf("admite como maximo: %ld \n\n",tipo_long_int);
bits++;
}
printf("long ................ %ibits .. de          %ld a           %ld \n\n",bits,tipo_long,tipo_long_max);
bits=1;
while(tipo_long_int>0){
tipo_long_int_max=tipo_long_int+(tipo_long_int-1);
tipo_long_int=tipo_long_int*2;
//printf("admite como maximo: %i \n\n",tipo_long_int);
bits++;
}
printf("long int ............ %ibits .. de          %i a           %i \n\n",bits,tipo_long_int,tipo_long_int_max);
bits=0;
while(tipo_unsigned_long_int>0){
tipo_unsigned_long_int_max=tipo_unsigned_long_int+(tipo_unsigned_long_int-1);
tipo_unsigned_long_int=tipo_unsigned_long_int*2;
//printf("admite como maximo: %i \n\n",tipo_unsigned_long_int);
bits++;
}
printf("unsigned long int ... %ibits .. de                    %u a           %u \n\n",bits,tipo_unsigned_long_int,tipo_unsigned_long_int_max);
bits=0;
while(tipo_unsigned_int>0){
tipo_unsigned_int_max=tipo_unsigned_int+(tipo_unsigned_int-1);
tipo_unsigned_int=tipo_unsigned_int*2;
//printf("admite como maximo: %i \n\n",tipo_unsigned_int);
bits++;
}
printf("unsigned int ........ %ibits .. de                    %u a           %u \n\n",bits,tipo_unsigned_int,tipo_unsigned_int_max);
bits=0;
while(tipo_unsigned_long>0){
tipo_unsigned_long_max=tipo_unsigned_long+(tipo_unsigned_long-1);
tipo_unsigned_long=tipo_unsigned_long*2;
//printf("admite como maximo: %i \n\n",tipo_unsigned_long);
bits++;
}
printf("unsigned long ....... %ibits .. de                    %u a           %u \n\n",bits,tipo_unsigned_long,tipo_unsigned_long_max);
bits=1;
while(tipo_long_long>0){
tipo_long_long_max=tipo_long_long+(tipo_long_long-1);
tipo_long_long=tipo_long_long*2;
//printf("admite como maximo: %ll \n",tipo_long_long);
bits++;
}
printf("long long ........... %ibits .. de %lld a  %lld \n\n",bits,tipo_long_long,tipo_long_long_max);
bits=0;
while(tipo_unsigned_long_long>0){
tipo_unsigned_long_long_max=tipo_unsigned_long_long+(tipo_unsigned_long_long-1);
tipo_unsigned_long_long=tipo_unsigned_long_long*2;
//printf("admite como maximo: %llu \n",tipo_unsigned_long_long);
bits++;
}
printf("unsigned long long .. %ibits .. de                    %llu a %llu \n\n",bits,tipo_unsigned_long_long,tipo_unsigned_long_long_max);

system("pause");


/*
%d--> for int

%ld--> for long int

%lld--> for long long int

%llu--> for unsigned long long int
*/
}


Y el resultado con Notepad++ y MinGW es este:

char ................. 8bits de                    -128 a                  127

unsigned char ........ 8bits .. de                    0 a                  255

short int ........... 16bits .. de               -32768 a                32767

unsigned short int .. 16bits .. de                    0 a                65535

int ................. 32bits .. de          -2147483648 a           2147483647

long ................ 32bits .. de          -2147483648 a           2147483647

long int ............ 32bits .. de          -2147483648 a           2147483647

unsigned long int ... 32bits .. de                    0 a           4294967295

unsigned int ........ 32bits .. de                    0 a           4294967295

unsigned long ....... 32bits .. de                    0 a           4294967295

long long ........... 64bits .. de -9223372036854775808 a  9223372036854775807

unsigned long long .. 64bits .. de                    0 a 18446744073709551615

[ivancea96]

La razón por la cual están esas variables es porque no está asegurado que esos tamaños sean así siempre.
Lo único asegurado es que los tamaños siguen estas condiciones:

Código (cpp) [Seleccionar] Expandir

char <= short <= int <= long <= long long