C Tipos e Limites

Esta é a página de consulta rápida dos tipos do C: quantos bytes cada um ocupa, o menor e o maior valor que cabe nele, o tipo de cada número escrito no código e o que acontece quando um valor não cabe. O C não fixa quase nenhum tamanho: ele muda de máquina para máquina. Por isso, cada tabela mostra os valores medidos em duas máquinas diferentes, o gcc da Ana e o editor do guia. Para aprender com calma, veja as aulas Tipos de Dados, Inteiros, float e double, sizeof e stdint.h.

gcc 15.2 da Ana

Linux de 64 bits num processador x86-64 (Intel/AMD), com a glibc. Pasta ~/c/ref, comando gcc -std=c23 -Wall -Wextra. É como a maioria dos computadores com Linux e macOS.

Editor do guia

Clang 22 gerando WebAssembly de 32 bits (wasm32), com a wasi-libc. Aqui, long, ponteiros e size_t têm 4 bytes, como nos computadores de 32 bits de antigamente.

Atalhos: Tamanhos (sizeof) · limits.h · stdint.h · float.h · O tipo dos literais · Conversões e estouros · Editor × gcc · Erros comuns · Experimente

Tamanhos: sizeof e alignof

sizeof(T) dá o tamanho do tipo em bytes; alignof(T) C23 (no C11, _Alignof) dá o alinhamento: o endereço de uma variável desse tipo é sempre múltiplo desse número. Medidos com este programa:

#include <stdio.h>
#include <stddef.h>
#include <stdint.h>
#include <wchar.h>
#include <uchar.h>

#define MOSTRA(T) printf("%-20s %2zu %2zu\n", #T, sizeof(T), alignof(T))

int main(void) {
    printf("%-20s %2s %2s\n", "tipo", "sz", "al");
    MOSTRA(char);
    MOSTRA(bool);
    MOSTRA(short);
    MOSTRA(int);
    MOSTRA(long);
    MOSTRA(long long);
    MOSTRA(float);
    MOSTRA(double);
    MOSTRA(long double);
    MOSTRA(void *);
    MOSTRA(int (*)(void));
    MOSTRA(size_t);
    MOSTRA(ptrdiff_t);
    MOSTRA(intptr_t);
    MOSTRA(intmax_t);
    MOSTRA(max_align_t);
    MOSTRA(wchar_t);
    MOSTRA(char8_t);
    MOSTRA(char16_t);
    MOSTRA(char32_t);
    MOSTRA(nullptr_t);
    MOSTRA(_BitInt(7));
    MOSTRA(_BitInt(100));
    MOSTRA(int_least8_t);
    MOSTRA(int_fast8_t);
    MOSTRA(int_fast16_t);
    MOSTRA(int_fast32_t);
    MOSTRA(int_fast64_t);
    printf("char tem sinal? %s\n", (char)-1 < 0 ? "sim" : "não");
    printf("wchar_t tem sinal? %s\n", (wchar_t)-1 < 0 ? "sim" : "não");
    return 0;
}

$ gcc -std=c23 -Wall -Wextra tamanhos.c -o tamanhos
$ ./tamanhos
tipo                 sz al
char                  1  1
bool                  1  1
short                 2  2
int                   4  4
long                  8  8
long long             8  8
float                 4  4
double                8  8
long double          16 16
void *                8  8
int (*)(void)         8  8
size_t                8  8
ptrdiff_t             8  8
intptr_t              8  8
intmax_t              8  8
max_align_t          32 16
wchar_t               4  4
char8_t               1  1
char16_t              2  2
char32_t              4  4
nullptr_t             8  8
_BitInt(7)            1  1
_BitInt(100)         16  8
int_least8_t          1  1
int_fast8_t           1  1
int_fast16_t          8  8
int_fast32_t          8  8
int_fast64_t          8  8
char tem sinal? sim
wchar_t tem sinal? sim

No editor, o char8_t não existe (error: use of undeclared identifier 'char8_t': a <uchar.h> da wasi-libc ainda não o tem). Sem essa linha, o programa roda, e as diferenças estão na tabela.

• char com ou sem sinal: nos dois, char sozinho tem sinal (vai de −128 a 127). Em processadores ARM (celulares, Raspberry Pi), ele costuma não ter (0 a 255). Para bytes, use unsigned char ou uint8_t.
• Os unsigned (unsigned short, unsigned int…) têm o mesmo tamanho do tipo com sinal.
• Só long, ponteiros e os tipos ligados a eles (size_t, ptrdiff_t, intptr_t, nullptr_t) mudam entre as duas máquinas. Se você precisa de um tamanho exato, use os tipos do stdint.h.

limits.h: o menor e o maior valor de cada inteiro

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

int main(void) {
    printf("CHAR_BIT   = %d\n", CHAR_BIT);
    printf("SCHAR_MIN  = %d\n", SCHAR_MIN);
    printf("SCHAR_MAX  = %d\n", SCHAR_MAX);
    printf("UCHAR_MAX  = %d\n", UCHAR_MAX);
    printf("CHAR_MIN   = %d\n", CHAR_MIN);
    printf("CHAR_MAX   = %d\n", CHAR_MAX);
    printf("SHRT_MIN   = %d\n", SHRT_MIN);
    printf("SHRT_MAX   = %d\n", SHRT_MAX);
    printf("USHRT_MAX  = %d\n", USHRT_MAX);
    printf("INT_MIN    = %d\n", INT_MIN);
    printf("INT_MAX    = %d\n", INT_MAX);
    printf("UINT_MAX   = %u\n", UINT_MAX);
    printf("LONG_MIN   = %ld\n", LONG_MIN);
    printf("LONG_MAX   = %ld\n", LONG_MAX);
    printf("ULONG_MAX  = %lu\n", ULONG_MAX);
    printf("LLONG_MIN  = %lld\n", LLONG_MIN);
    printf("LLONG_MAX  = %lld\n", LLONG_MAX);
    printf("ULLONG_MAX = %llu\n", ULLONG_MAX);
    printf("BOOL_WIDTH = %d, CHAR_WIDTH = %d, SHRT_WIDTH = %d, INT_WIDTH = %d\n", BOOL_WIDTH, CHAR_WIDTH, SHRT_WIDTH, INT_WIDTH);
    printf("LONG_WIDTH = %d, LLONG_WIDTH = %d\n", LONG_WIDTH, LLONG_WIDTH);
    printf("BITINT_MAXWIDTH = %llu\n", (unsigned long long)BITINT_MAXWIDTH);
    printf("MB_LEN_MAX = %d\n", MB_LEN_MAX);
    return 0;
}

Os tipos com sinal vão de −2^N−1 a 2^N−1 − 1, e os sem sinal, de 0 a 2^N − 1, onde N é o número de bits. Por isso o mínimo tem "um a mais" que o máximo: INT_MIN = −2147483648, INT_MAX = 2147483647.

stdint.h: inteiros de tamanho fixo

Quando o tamanho importa (um arquivo binário, um protocolo de rede, um valor que passa de 2 bilhões), use os tipos do <stdint.h> C99: eles têm o mesmo tamanho em toda máquina. Aula: stdint.h.

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

int main(void) {
    printf("INT8_MIN   = %" PRId8 ", INT8_MAX = %" PRId8 ", UINT8_MAX = %" PRIu8 "\n", INT8_MIN, INT8_MAX, UINT8_MAX);
    printf("INT16_MIN  = %" PRId16 ", INT16_MAX = %" PRId16 ", UINT16_MAX = %" PRIu16 "\n", INT16_MIN, INT16_MAX, UINT16_MAX);
    printf("INT32_MIN  = %" PRId32 ", INT32_MAX = %" PRId32 "\n", INT32_MIN, INT32_MAX);
    printf("UINT32_MAX = %" PRIu32 "\n", UINT32_MAX);
    printf("INT64_MIN  = %" PRId64 "\n", INT64_MIN);
    printf("INT64_MAX  = %" PRId64 "\n", INT64_MAX);
    printf("UINT64_MAX = %" PRIu64 "\n", UINT64_MAX);
    printf("INTMAX_MAX = %" PRIdMAX "\n", INTMAX_MAX);
    printf("SIZE_MAX   = %zu\n", (size_t)SIZE_MAX);
    printf("PTRDIFF_MAX = %td\n", (ptrdiff_t)PTRDIFF_MAX);
    printf("INTPTR_MAX = %" PRIdPTR "\n", (intptr_t)INTPTR_MAX);
    printf("PRId64 = \"%s\", PRIu64 = \"%s\", PRIdPTR = \"%s\"\n", PRId64, PRIu64, PRIdPTR);
    return 0;
}

$ gcc -std=c23 -Wall -Wextra fixos.c -o fixos
$ ./fixos
INT8_MIN   = -128, INT8_MAX = 127, UINT8_MAX = 255
INT16_MIN  = -32768, INT16_MAX = 32767, UINT16_MAX = 65535
INT32_MIN  = -2147483648, INT32_MAX = 2147483647
UINT32_MAX = 4294967295
INT64_MIN  = -9223372036854775808
INT64_MAX  = 9223372036854775807
UINT64_MAX = 18446744073709551615
INTMAX_MAX = 9223372036854775807
SIZE_MAX   = 18446744073709551615
PTRDIFF_MAX = 9223372036854775807
INTPTR_MAX = 9223372036854775807
PRId64 = "ld", PRIu64 = "lu", PRIdPTR = "ld"

• Por que PRId64? Porque o int64_t é um long no gcc (PRId64 vira "ld") e um long long no editor (vira "lld"). Escrever %ld à mão funcionaria só numa das duas máquinas. Veja a tabela do printf.
• Literais de tamanho fixo: INT64_C(5000000000) e UINT32_C(7) escrevem o número já com o tipo certo.
• No editor, os casts (size_t)SIZE_MAX são necessários: lá, SIZE_MAX, PTRDIFF_MAX e INTPTR_MAX são unsigned int/int, e o Clang avisa format specifies type 'size_t' (aka 'unsigned long') but the argument has type 'unsigned int' num %zu sem o cast. No gcc, não faz diferença.

float.h: limites do ponto flutuante

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

int main(void) {
    printf("FLT_RADIX = %d, FLT_EVAL_METHOD = %d\n", FLT_RADIX, FLT_EVAL_METHOD);
    printf("float:  MANT_DIG = %d, DIG = %d, DECIMAL_DIG = %d\n", FLT_MANT_DIG, FLT_DIG, FLT_DECIMAL_DIG);
    printf("        MIN = %g, MAX = %g, EPSILON = %g, TRUE_MIN = %g\n", FLT_MIN, FLT_MAX, FLT_EPSILON, FLT_TRUE_MIN);
    printf("double: MANT_DIG = %d, DIG = %d, DECIMAL_DIG = %d\n", DBL_MANT_DIG, DBL_DIG, DBL_DECIMAL_DIG);
    printf("        MIN = %g, MAX = %g, EPSILON = %g, TRUE_MIN = %g\n", DBL_MIN, DBL_MAX, DBL_EPSILON, DBL_TRUE_MIN);
    printf("long double: MANT_DIG = %d, DIG = %d, DECIMAL_DIG = %d\n", LDBL_MANT_DIG, LDBL_DIG, LDBL_DECIMAL_DIG);
    printf("        MIN = %Lg, MAX = %Lg, EPSILON = %Lg\n", LDBL_MIN, LDBL_MAX, LDBL_EPSILON);
    printf("FLT_MIN_EXP = %d, FLT_MAX_EXP = %d, FLT_MAX_10_EXP = %d\n", FLT_MIN_EXP, FLT_MAX_EXP, FLT_MAX_10_EXP);
    printf("DBL_MIN_10_EXP = %d, DBL_MAX_10_EXP = %d\n", DBL_MIN_10_EXP, DBL_MAX_10_EXP);
    printf("DECIMAL_DIG = %d\n", DECIMAL_DIG);
    return 0;
}

$ gcc -std=c23 -Wall -Wextra flutuante.c -o flutuante
$ ./flutuante
FLT_RADIX = 2, FLT_EVAL_METHOD = 0
float:  MANT_DIG = 24, DIG = 6, DECIMAL_DIG = 9
        MIN = 1.17549e-38, MAX = 3.40282e+38, EPSILON = 1.19209e-07, TRUE_MIN = 1.4013e-45
double: MANT_DIG = 53, DIG = 15, DECIMAL_DIG = 17
        MIN = 2.22507e-308, MAX = 1.79769e+308, EPSILON = 2.22045e-16, TRUE_MIN = 4.94066e-324
long double: MANT_DIG = 64, DIG = 18, DECIMAL_DIG = 21
        MIN = 3.3621e-4932, MAX = 1.18973e+4932, EPSILON = 1.0842e-19
FLT_MIN_EXP = -125, FLT_MAX_EXP = 128, FLT_MAX_10_EXP = 38
DBL_MIN_10_EXP = -307, DBL_MAX_10_EXP = 308
DECIMAL_DIG = 21

No editor, por causa do %Lg, o programa precisa de data-flags="-std=c23 -Wall -Wextra -lc-printscan-long-double" (veja o aviso do printf). Com isso, float e double saem iguais; o long double é diferente (tabela abaixo).

Na prática: um float guarda uns 6 a 7 algarismos; um double, 15 a 16. Para dinheiro, guarde centavos num inteiro (long long centavos). Para comparar dois double, use uma tolerância: fabs(a - b) < 1e-9. Aula: float e double.

O tipo de cada literal

Todo número escrito no código (um literal) tem um tipo. Medido com _Generic (aula _Generic), que escolhe um texto conforme o tipo:

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

#define TIPO(x) _Generic((x), \
    char: "char", int: "int", unsigned: "unsigned int", \
    long: "long", unsigned long: "unsigned long", \
    long long: "long long", unsigned long long: "unsigned long long", \
    float: "float", double: "double", long double: "long double", \
    bool: "bool", nullptr_t: "nullptr_t", default: "outro")

int main(void) {
    printf("42          -> %s\n", TIPO(42));
    printf("42u         -> %s\n", TIPO(42u));
    printf("42L         -> %s\n", TIPO(42L));
    printf("42LL        -> %s\n", TIPO(42LL));
    printf("42ull       -> %s\n", TIPO(42ull));
    printf("2147483648  -> %s\n", TIPO(2147483648));
    printf("0xFFFFFFFF  -> %s\n", TIPO(0xFFFFFFFF));
    printf("3.14        -> %s\n", TIPO(3.14));
    printf("3.14f       -> %s\n", TIPO(3.14f));
    printf("3.14L       -> %s\n", TIPO(3.14L));
    printf("'A'         -> %s\n", TIPO('A'));
    printf("true        -> %s\n", TIPO(true));
    printf("nullptr     -> %s\n", TIPO(nullptr));
    printf("1'000'000   -> %d\n", 1'000'000);
    printf("0b1010      -> %d\n", 0b1010);
    printf("sizeof(3wb) = %zu, sizeof(200uwb) = %zu\n", sizeof(3wb), sizeof(200uwb));
    char c = 'A';
    printf("c + 1       -> %s\n", TIPO(c + 1));
    printf("1u + -2     -> %s = %u\n", TIPO(1u + -2), 1u + -2);
    printf("-1 < 1u     -> %d\n", -1 < 1u);
    printf("(unsigned char)300 = %d, (signed char)200 = %d\n", (unsigned char)300, (signed char)200);
    printf("UINT_MAX + 1u = %u\n", UINT_MAX + 1u);
    printf("(int)3.99 = %d, (int)-3.99 = %d\n", (int)3.99, (int)-3.99);
    float f = 16777217;
    printf("float 16777217 -> %.1f\n", f);
    printf("0.1f == 0.1 -> %d\n", 0.1f == 0.1);
    return 0;
}

$ gcc -std=c23 -Wall -Wextra literais.c -o literais
literais.c: In function ‘main’:
literais.c:32:38: warning: comparison of integer expressions of different signedness: ‘int’ and ‘unsigned int’ [-Wsign-compare]
   32 |     printf("-1 < 1u     -> %d\n", -1 < 1u);
      |                                      ^
$ ./literais
42          -> int
42u         -> unsigned int
42L         -> long
42LL        -> long long
42ull       -> unsigned long long
2147483648  -> long                               « no editor: long long
0xFFFFFFFF  -> unsigned int
3.14        -> double
3.14f       -> float
3.14L       -> long double
'A'         -> int
true        -> bool
nullptr     -> nullptr_t
1'000'000   -> 1000000
0b1010      -> 10
sizeof(3wb) = 1, sizeof(200uwb) = 1
c + 1       -> int
1u + -2     -> unsigned int = 4294967295
-1 < 1u     -> 0
(unsigned char)300 = 44, (signed char)200 = -56
UINT_MAX + 1u = 0
(int)3.99 = 3, (int)-3.99 = -3
float 16777217 -> 16777216.0
0.1f == 0.1 -> 0

No editor, o Clang não dá o aviso do -1 < 1u, mas dá outros dois (veja Erros comuns). A única diferença na saída é a do 2147483648.

Conversões e estouros

Para saber, antes de fazer a conta, se ela vai estourar, o C23 trouxe o <stdckdint.h>: ckd_add(&total, a, b) devolve true se estourou. Aula: Inteiros.

Editor × gcc

Iguais nos dois: char, short, int, long long, float, double, bool, wchar_t, todos os intN_t, INT_MAX, os limites de float e double, as regras de conversão e o char com sinal. Para um programa funcionar igual em qualquer máquina, use int, long long e os tipos do stdint.h, nunca long.

Erros comuns

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

int main(void) {
    int populacao = 3000000000;
    char letra = 300;
    int depois = INT_MAX + 1;
    unsigned int positivo = -1;
    long grande = 3000000000;
    printf("%d %d %d %u %ld\n", populacao, letra, depois, positivo, grande);
    return 0;
}

$ gcc -std=c23 -Wall -Wextra estouro.c -o estouro
estouro.c: In function ‘main’:
estouro.c:6:18: warning: overflow in conversion from ‘int’ to ‘char’ changes value from ‘300’ to ‘44’ [-Woverflow]
    6 |     char letra = 300;
      |                  ^~~
estouro.c:7:26: warning: integer overflow in expression of type ‘int’ results in ‘-2147483648’ [-Woverflow]
    7 |     int depois = INT_MAX + 1;
      |                          ^
$ ./estouro
-1294967296 44 -2147483648 4294967295 3000000000

Experimente

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

struct produto {
    char codigo;
    int quantidade;
    double preco;
};

int main(void) {
    printf("int: %zu bytes, long: %zu, long long: %zu\n", sizeof(int), sizeof(long), sizeof(long long));
    printf("ponteiro: %zu bytes, size_t: %zu\n", sizeof(void *), sizeof(size_t));
    printf("int64_t: %zu bytes\n", sizeof(int64_t));
    printf("struct produto: %zu bytes (1 + 4 + 8 = 13 sem os buracos)\n", sizeof(struct produto));
    printf("INT_MAX = %d, LONG_MAX = %ld\n", INT_MAX, LONG_MAX);
    return 0;
}

#include <stdio.h>

int main(void) {
    int janeiro = 1500000000;
    int fevereiro = 1500000000;
    int total = janeiro + fevereiro;
    printf("Total: %d\n", total);
    return 0;
}

#include <stdio.h>

int main(void) {
    int janeiro = 1500000000;
    int fevereiro = 1500000000;
    long long total = (long long)janeiro + fevereiro;
    printf("Total: %lld\n", total);
    return 0;
}

Resumo

• Iguais em quase toda máquina: char 1, short 2, int 4, long long 8, float 4, double 8 bytes.
• Mudam: long, ponteiros e size_t (8 bytes no Linux de 64 bits, 4 no editor). Para tamanho exato, int32_t, int64_t… do stdint.h, com PRId64 no printf.
• Limites: INT_MAX = 2147483647, LLONG_MAX = 9223372036854775807 (limits.h); DBL_EPSILON, DBL_DIG = 15 (float.h).
• Sem sinal dá a volta; conta com sinal que estoura é comportamento indefinido. Converta antes da conta: (long long)a + b.
• Cuidado com int × unsigned (-1 < 1u é falso) e com 'A', que é um int.