Tipos de variáveis de memória

Que tipo de variável utilizar

O tipo da variável de memória, em linguagens ditas fortemente tipadas, define o tipo de dado que esta pode armazenar. Os tipos nativos da linguagem c e c++ são tipos para números inteiros e números de ponto flutuante (para representar números reais), ou seja, uma variável pode armazenar números como 42 ou 3.1416, por exemplo, dependendo de como é declarada. Carateres de textos são armazenados em variáveis de tipo inteiro.

Ao trabalhar com tipos de ponto flutuante não se esqueça tomar alguns cuidados com a precisão numérica.

Qual a vantagem de haver tipos de variáveis de memória diferentes?

1. O fato de uma linguagem oferecer vários tipos nativos (criados com a linguagem) permite ao programador controlar melhor a quantidade de memória alocada para suas variáveis.
2. Operações com um determinado tipo podem também ser mais rápidas que com outros tipo, dependendo da plataforma. Você só deve se preocupar com estes detalhes se a performance do seu programa for uma questão crucial, mesmo assim, mudando seu programa de plataforma, o resultado pode mudar.

Vejamos dois exemplos

1. Em uma determinada plataforma o tipo char ocupa 1 byte (8 bits) e o tipo int ocupa 4 bytes (32 bits). Se no meu programa preciso somente trabalhar com números entre -128 e 127 e utilizo int, que permite um intervalo maior, 4 vezes mais memória será necessário. O que ocuparia 500MB com char, vai ocupar 2GB com int.
2. Os tipo com ponto flutuante (float ou double) podem exigir mais ciclos de máquina para executar uma operação que os tipos inteiros, entretanto, este fato é altamente dependente da arquitetura.

Os tipos básicos em c e c++ são:

1. Inteiros: char, short, int e long
2. Ponto flutuante: float e double

Cada tipo tem um tamanho e pode representar um intervalo de valores. Existem também os qualificadores de tipo (unsigned e long, por exemplo) que permitem modificar o tamanho e sinal dos tipos no caso de inteiros e a precisão no caso do tipo double, por exemplo:

char c;        // 8bits -> inteiro (-128 a 127)
unsigned char; // 8bits -> inteiro sem sinal (0 a 255)
double d;
long double x; //maior precisão que double, dependendo da plataforma

Veja aqui mais detalhes sobre tamanhos que ocupam, intervalos que podem representar e precisão dos tipos em c.

Que tipo usar?

1. Se seus cálculos não necessitarem casas decimais, utilize tipos inteiros, caso contrário utilize ponto flutuante. Por exemplo, utilize números inteiros para fazer contagens e ponto flutuante para calcular o valor médio de sua contagem.
2. Em caso de tipos inteiros, verifique o intervalo numérico que deseja utilizar, se o números são positivos somente (unsigned) ou podem também ter valores negativos.
3. No caso de pontos flutuantes, se a precisão não for um problema, use float. Se precisar de mais precisão use double ou long double (se estiver disponível na implementação de sua plataforma).

Dependência da plataforma

Os tamanhos (número de bits) dos tipos em c podem variar de acordo com a plataforma. Se você escrever um código para rodar corretamente com inteiros de 32 bits e portar seu código para uma plataforma com inteiros de 16 bits, certamente terá problemas.

Para contornar este problema você pode utilizar tipos independentes da plataforma, definidos no arquivo de cabeçalho inttypes.h:

#include <inttypes.h>
int main(void)
{
   int8_t  i; //inteiro de 8bits (-128 a 127)
   uint8_t i; //inteiro de 8bits (0 a 255)
   int16_t  k; //inteiro de 16 bits −32768 a +32767
   uint16_t l; //inteiro de 16 bits sem sinal 0 a 65365
   int32_t  m; //inteiro de 32bits
}

Verificando tamanho dos tipos da plataforma

Compile e rode o código abaixo para saber os tamanho dos tipos de sua plataforma.

#include <stdio.h>
int main(void)
{
    printf("char: \t%d bytes\n", sizeof(char));
    printf("short: \t%d bytes\n", sizeof(short));
    printf("int: \t%d bytes\n", sizeof(int));
    printf("long: \t%d bytes\n", sizeof(long));
    printf("float: \t%d bytes\n", sizeof(float));
    printf("double: \t%d bytes\n", sizeof(double));
    printf("long double: \t%d bytes\n", sizeof(long double));
    return 0;
}
Resultado (arquitetura x64)
char:  1 bytes
short: 4 bytes
int:   4 bytes
long:  8 bytes
float: 4 bytes
double:       8 bytes
long double:  16 bytes