Docs executáveis de C: Tipos de dados

Q: Quais são os tipos de dados básicos em C?

Quatro tipos base: char para caracteres isolados e bytes, int para números inteiros, float e double para decimais. Modificadores mudam o tamanho e o sinal deles - short, long, long long, signed e unsigned - produzindo o conjunto completo.

Q: Qual é a diferença entre float e double em C?

float tem 4 bytes com cerca de 7 dígitos decimais significativos; double tem 8 bytes com cerca de 15. Double é o padrão para literais de ponto flutuante e para as funções matemáticas e, a menos que você esteja guardando milhões de valores ou mirando um chip embarcado, double é a escolha certa.

Q: O que acontece quando um int estoura em C?

Para um int com sinal, o estouro é comportamento indefinido - o compilador pode dar a volta, saturar ou eliminar a verificação por completo. Para um int sem sinal ele é totalmente definido: o valor dá a volta módulo 2^N, então UINT_MAX + 1 é 0. Nunca dependa do estouro com sinal.

Toda variável em C tem um tipo, escolhido quando você a declara e fixo por toda a vida dela. O tipo decide três coisas: quantos bytes a variável ocupa, como esses bytes são interpretados e quais operações fazem sentido nela.

A lista de tipos do C é curta. A complexidade está nos modificadores.

Os quatro tipos base

#include <stdio.h>

int main(void) {
    char  initial = 'K';        /* um caractere / um byte */
    int   count   = 42;         /* número inteiro */
    float ratio   = 3.14f;      /* decimal, precisão simples */
    double precise = 3.141592653589793;  /* decimal, precisão dupla */

    printf("char:   %c\n", initial);
    printf("int:    %d\n", count);
    printf("float:  %f\n", ratio);
    printf("double: %.15f\n", precise);
    return 0;
}

char guarda um byte. É usado para caracteres isolados ('A'), para os bytes de uma string e às vezes como um inteiro minúsculo.
int é o tipo burro de carga para números inteiros. Contadores de laço, tamanhos, IDs.
float e double guardam números reais. double tem mais ou menos o dobro da precisão.
void é o quarto tipo, em certo sentido, mas significa "nenhum valor" - você não pode declarar uma variável void, só usá-lo como tipo de retorno de função, lista de parâmetros vazia ou ponteiro sem tipo.

Note o sufixo f em 3.14f. Sem ele o literal é um double, e atribuí-lo a um float perde precisão silenciosamente. Alguns compiladores avisam.

Modificadores: short, long, unsigned

Os tipos inteiros base vêm com modificadores que mudam o tamanho ou o sinal.

#include <stdio.h>

int main(void) {
    short small = 32000;
    int normal = 2000000;
    long big = 2000000000L;
    long long huge = 9000000000000000000LL;

    unsigned int positive_only = 4000000000U;

    printf("short:        %hd\n", small);
    printf("int:          %d\n", normal);
    printf("long:         %ld\n", big);
    printf("long long:    %lld\n", huge);
    printf("unsigned int: %u\n", positive_only);
    return 0;
}

Cada tipo inteiro precisa do seu próprio especificador de formato: %hd para short, %d para int, %ld para long, %lld para long long, %u para unsigned. Usar o errado é comportamento indefinido, não um erro de arredondamento.

unsigned remove o bit de sinal e dobra a faixa positiva. Um unsigned int guarda de 0 a cerca de 4,3 bilhões em vez de -2,1 a +2,1 bilhões. É a escolha certa para coisas que genuinamente não podem ser negativas - tamanhos, contagens de bytes, padrões de bits - e uma armadilha para qualquer coisa de que se possa subtrair abaixo de zero.

signed é o padrão para int, short, long e long long, então você quase nunca o escreve. O único lugar onde ele importa é o char: se o char simples é com ou sem sinal é definido pela implementação, então escreva signed char ou unsigned char quando o sinal importar.

Tamanhos: o que você realmente recebe

O padrão C especifica mínimos, não tamanhos exatos. Em qualquer máquina moderna de 64 bits com Linux, macOS ou Windows você vai ver isto:

Tipo	Tamanho típico	Faixa típica
`char`	1 byte	-128 a 127 (ou 0 a 255)
`short`	2 bytes	-32.768 a 32.767
`int`	4 bytes	-2.147.483.648 a 2.147.483.647
`long`	8 bytes (4 no Windows)	mais ou menos ±9,2 quintilhões
`long long`	8 bytes	mais ou menos ±9,2 quintilhões
`float`	4 bytes	~7 dígitos significativos
`double`	8 bytes	~15 dígitos significativos
`long double`	16 bytes (varia)	mais que o double

A linha do long é a que pega as pessoas: ele tem 8 bytes no Linux e no macOS, e 4 bytes no Windows de 64 bits. Código que supõe que long guarda um valor de 64 bits não é portável. Use long long, ou os tipos de largura exata de stdint.h (int32_t, uint64_t) quando o tamanho faz parte do requisito.

sizeof: pergunte ao compilador

Nunca adivinhe um tamanho - meça:

#include <stdio.h>

int main(void) {
    printf("char:        %zu byte(s)\n", sizeof(char));
    printf("short:       %zu bytes\n", sizeof(short));
    printf("int:         %zu bytes\n", sizeof(int));
    printf("long:        %zu bytes\n", sizeof(long));
    printf("long long:   %zu bytes\n", sizeof(long long));
    printf("float:       %zu bytes\n", sizeof(float));
    printf("double:      %zu bytes\n", sizeof(double));
    printf("um ponteiro: %zu bytes\n", sizeof(int *));
    return 0;
}

sizeof é um operador, não uma função, e é avaliado em tempo de compilação. Ele produz um valor do tipo size_t, que se imprime com %zu.

sizeof(char) tem garantia de ser exatamente 1 - essa é a definição de byte em C. Todo o resto é medido em relação a ele.

limits.h e float.h

As faixas exatas do seu compilador estão disponíveis como constantes nomeadas:

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

int main(void) {
    printf("INT_MIN      = %d\n", INT_MIN);
    printf("INT_MAX      = %d\n", INT_MAX);
    printf("UINT_MAX     = %u\n", UINT_MAX);
    printf("LONG_MAX     = %ld\n", LONG_MAX);
    printf("CHAR_BIT     = %d bits por byte\n", CHAR_BIT);
    printf("FLT_DIG      = %d dígitos decimais\n", FLT_DIG);
    printf("DBL_DIG      = %d dígitos decimais\n", DBL_DIG);
    return 0;
}

Esses são os valores com que comparar quando você precisa saber se uma operação vai estourar. Verificar if (a > INT_MAX - b) antes de calcular a + b é como se detecta um estouro antes de ele acontecer - o que importa, porque não dá para detectar estouro com sinal depois.

Estouro de inteiros

O que acontece quando um valor excede a faixa do seu tipo depende inteiramente do sinal.

O estouro sem sinal é definido: o valor dá a volta módulo 2^N.

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

int main(void) {
    unsigned int u = UINT_MAX;
    printf("UINT_MAX     = %u\n", u);
    printf("UINT_MAX + 1 = %u\n", u + 1);   /* garantidamente 0 */

    unsigned int zero = 0;
    printf("0 - 1        = %u\n", zero - 1); /* dá a volta para UINT_MAX */
    return 0;
}

Esse segundo caso é uma fonte real de bugs. Um laço como for (unsigned i = n - 1; i >= 0; i--) nunca termina, porque um valor sem sinal é sempre >= 0.

O estouro com sinal é comportamento indefinido. Não é "dá a volta" - é indefinido. O compilador tem permissão de supor que isso nunca acontece e otimizar com base nisso, o que significa que uma verificação de estouro escrita depois do fato pode ser eliminada:

int sum = a + b;
if (sum < a) { /* o compilador pode remover isto inteiro */ }

Verifique antes, usando os limites:

if (b > 0 && a > INT_MAX - b) {
    /* a + b estouraria - trate o caso */
}

Precisão de ponto flutuante

float e double guardam números em binário, e a maioria das frações decimais não tem forma binária exata - do mesmo jeito que 1/3 não tem forma decimal exata.

#include <stdio.h>

int main(void) {
    double a = 0.1;
    double b = 0.2;
    double sum = a + b;

    printf("0.1 + 0.2 = %.20f\n", sum);
    printf("É 0.3? %s\n", (sum == 0.3) ? "sim" : "não");

    /* O jeito certo: comparar dentro de uma tolerância. */
    double diff = sum - 0.3;
    if (diff < 0) diff = -diff;
    printf("Perto o bastante? %s\n", (diff < 1e-9) ? "sim" : "não");
    return 0;
}

A regra que decorre disso: nunca compare valores de ponto flutuante com ==. Compare a diferença absoluta contra uma pequena tolerância.

E nunca use ponto flutuante para dinheiro. Guarde centavos como um inteiro; um long long de centavos é exato onde um double de reais não é.

Escolhendo um tipo

Uma lista curta de decisão que cobre a maior parte do código:

Números inteiros: int, a menos que você tenha um motivo. É o tipo que a CPU trata com mais eficiência e o tipo em torno do qual todas as regras de aritmética foram construídas.
Qualquer coisa maior que 2 bilhões: long long, ou int64_t de stdint.h.
Tamanhos, comprimentos e índices de array vindos de sizeof ou strlen: size_t. Ele é sem sinal e tem garantia de ser grande o bastante para qualquer objeto.
Decimais: double. Use float só para reduzir memória pela metade em arrays grandes ou em hardware embarcado sem unidade de precisão dupla.
Caracteres isolados e bytes crus: char para texto, unsigned char para dados binários.
Verdadeiro/falso: bool de stdbool.h - veja booleanos em C.
Larguras exatas de bits (formatos de arquivo, protocolos de rede, registradores de hardware): stdint.h - uint8_t, int16_t, uint32_t e assim por diante.

#include <stdio.h>
#include <stdint.h>

int main(void) {
    uint8_t  flags = 0xFF;          /* exatamente 8 bits, sem sinal */
    int32_t  offset = -100000;      /* exatamente 32 bits, com sinal */
    uint64_t file_size = 5000000000ULL;

    printf("flags:     %u\n", flags);
    printf("offset:    %d\n", offset);
    printf("file_size: %llu bytes\n", (unsigned long long)file_size);
    return 0;
}

Misturar tipos

Quando você combina dois tipos diferentes numa mesma expressão, C os converte por trás dos panos antes de fazer a aritmética. Isso normalmente ajuda e ocasionalmente é desastroso:

#include <stdio.h>

int main(void) {
    int a = 7, b = 2;

    printf("7 / 2  como ints = %d\n", a / b);        /* 3, e não 3.5 */
    printf("7 / 2  com 2.0   = %f\n", a / 2.0);      /* 3.5 */

    int  small = -1;
    unsigned int big = 1;
    printf("-1 < 1u ? %s\n", (small < big) ? "sim" : "não");  /* surpreendente */
    return 0;
}

A primeira é divisão inteira: os dois operandos são int, então o resultado é um int e a fração é descartada. A terceira é pior - comparar um valor com sinal com um sem sinal converte o com sinal para sem sinal, transformando -1 num número positivo enorme.

Essas regras de conversão, e como assumir o controle delas com casts explícitos, são o assunto de conversão de tipos em C.

Perguntas frequentes

Quais são os tipos de dados básicos em C?

Quatro tipos base: char para caracteres isolados e bytes, int para números inteiros, float e double para decimais. Modificadores mudam o tamanho e o sinal deles - short, long, long long, signed e unsigned - produzindo o conjunto completo.

Quantos bytes tem um int em C?

Quase sempre 4 bytes (32 bits) em sistemas modernos de desktop e servidor, dando uma faixa de cerca de -2,1 bilhões a 2,1 bilhões. O padrão só garante pelo menos 2 bytes, e microcontroladores de 16 bits realmente usam 2. Use sizeof(int) se precisar saber com certeza.

Qual é a diferença entre float e double em C?

float tem 4 bytes com cerca de 7 dígitos decimais significativos; double tem 8 bytes com cerca de 15. Double é o padrão para literais de ponto flutuante e para as funções matemáticas e, a menos que você esteja guardando milhões de valores ou mirando um chip embarcado, double é a escolha certa.

O que acontece quando um int estoura em C?

Para um int com sinal, o estouro é comportamento indefinido - o compilador pode dar a volta, saturar ou eliminar a verificação por completo. Para um int sem sinal ele é totalmente definido: o valor dá a volta módulo 2^N, então UINT_MAX + 1 é 0. Nunca dependa do estouro com sinal.

Conceitos relacionados