C++ Tipos e Limites

Quantos bytes tem um int? Qual o maior número que cabe num short? Que tipo tem o literal 42ul? Esta página responde de uma vez, em tabelas. Todos os valores foram medidos na máquina da Ana (Linux x86-64, g++ 15.2) com sizeof e std::numeric_limits. Para aprender com calma, veja Tipos de Dados, Inteiros, float e double, char e bool.

Atalhos: Inteiros · Caracteres e bool · Ponto flutuante · <cstdint> · Literais e sufixos · numeric_limits · Outros sistemas · Armadilhas

Para conferir no seu computador

#include <cstdint>
#include <iostream>
#include <limits>

int main() {
    std::cout << "int: " << sizeof(int) << " bytes, de "
              << std::numeric_limits<int>::min() << " a "
              << std::numeric_limits<int>::max() << '\n';
    std::cout << "long: " << sizeof(long) << " bytes\n";
    std::cout << "int64_t até " << std::numeric_limits<std::int64_t>::max() << '\n';
    std::cout << "double: " << std::numeric_limits<double>::digits10
              << " dígitos garantidos\n";
}

$ g++ -std=c++23 -Wall -Wextra tamanhos.cpp -o tamanhos
$ ./tamanhos
int: 4 bytes, de -2147483648 a 2147483647
long: 8 bytes
int64_t até 9223372036854775807
double: 15 dígitos garantidos

#include <cstdint>
#include <iostream>
#include <limits>

int main() {
    std::cout << "int: " << sizeof(int) << " bytes, de "
              << std::numeric_limits<int>::min() << " a "
              << std::numeric_limits<int>::max() << '\n';
    std::cout << "long: " << sizeof(long) << " bytes\n";
    std::cout << "int64_t até " << std::numeric_limits<std::int64_t>::max() << '\n';
    std::cout << "double: " << std::numeric_limits<double>::digits10
              << " dígitos garantidos\n";
}

Inteiros

Com sinal (signed) guardam negativos; sem sinal (unsigned) só zero e positivos, mas vão duas vezes mais longe. short = short int, long = long int, unsigned = unsigned int. Aula: Inteiros.

Para ter uma ideia: o int vai até uns 2,1 bilhões; o long long, até uns 9,2 quintilhões (9,2 × 10¹⁸). std::size_t é o tipo que sizeof e .size() devolvem; std::ptrdiff_t, o da diferença entre dois ponteiros. No Linux x86-64, são unsigned long e long.

Caracteres e bool

Aulas: char, bool e Acentos e UTF-8.

char, signed char e unsigned char são três tipos diferentes. Se o char puro tem sinal ou não depende da plataforma: tem no x86-64 e no macOS, não tem no Linux em ARM (Raspberry Pi, por exemplo). Por isso, para examinar bytes, use unsigned char.

Ponto flutuante

Aula: float e double. "Dígitos" é digits10: quantos dígitos decimais sempre sobrevivem à ida e volta.

• O mais negativo é lowest(), igual a −max() (por exemplo, −1.7976931348623157e+308). Atenção: min() de ponto flutuante é o menor positivo, não o mais negativo.
• Epsilon é a distância entre 1 e o próximo número representável: a "resolução" do tipo perto de 1.
• Use double como padrão. float só quando a memória importa muito (gráficos, milhões de valores).
• No x86-64 Linux, o long double ocupa 16 bytes, mas usa 80 bits de precisão (o resto é enchimento).

Nenhum deles guarda 0,1 exatamente. Com 20 casas (std::format("{:.20f}", …)): 0.1f → 0.10000000149011611938 e 0.1 → 0.10000000000000000555. E 0.1 + 0.2 == 0.3 é false: a soma dá 0.30000000000000004.

Inteiros de tamanho fixo: <cstdint>

Quando o tamanho exato importa (arquivos binários, rede, ou só para não depender do sistema), use os tipos de <cstdint>. Eles são apelidos para os tipos acima: no Linux x86-64, std::int64_t é long; no Windows, long long. O nome diz o tamanho em todo lugar.

Os nomes também existem sem o std:: (int32_t), herança do C; com <cstdint>, prefira escrever o std::.

Literais e sufixos

Um literal é um valor escrito direto no código. O tipo dele vem da forma e do sufixo (maiúsculo ou minúsculo dá no mesmo: 42UL = 42ul; prefira L maiúsculo, que não se confunde com 1). Todos os tipos desta tabela foram confirmados com static_assert no g++ 15.

std::numeric_limits

De <limits>. Pergunte ao compilador em vez de decorar: std::numeric_limits<T>::membro. Os INT_MAX, LLONG_MIN… de <climits> são a versão antiga, do C.

65535
32767

#include <cstdint>
#include <iostream>
#include <limits>

int main() {
    // seu código aqui
}

#include <cstdint>
#include <iostream>
#include <limits>

int main() {
    std::cout << std::numeric_limits<std::uint16_t>::max() << '\n';
    std::cout << std::numeric_limits<std::int16_t>::max() << '\n';
}

Outros sistemas

As diferenças que importam, conferidas com o clang++ 21 do laboratório apontado para cada sistema (--target=…, com static_assert):

short (2), int (4), long long (8), float (4) e double (8) são iguais em todos eles. Moral: para inteiros grandes, long long ou std::int64_t, nunca long.

Armadilhas

1. std::uint8_t sai como letra. Ele é um unsigned char, e o cout mostra char como caractere:

#include <cstdint>
#include <iostream>

int main() {
    std::uint8_t idade = 65;
    std::cout << "Idade: " << idade << '\n';
    std::cout << "Idade: " << +idade << '\n';
    std::cout << "Idade: " << static_cast<int>(idade) << '\n';
}

$ g++ -std=c++23 -Wall -Wextra uint8.cpp -o uint8
$ ./uint8
Idade: A
Idade: 65
Idade: 65

65 é o código do A. O + na frente promove para int; o static_cast<int> diz o mesmo de forma explícita. O std::format("{}", idade) mostra 65.

2. Estouro: o valor não cabe.

#include <climits>
#include <iostream>

int main() {
    int a = 3000000000;
    int b = INT_MAX + 1;
    unsigned c = -1;
    short d = 70000;
    std::cout << a << ' ' << b << ' ' << c << ' ' << d << '\n';
}

$ g++ -std=c++23 -Wall -Wextra estouro.cpp -o estouro
estouro.cpp: In function ‘int main()’:
estouro.cpp:6:21: warning: integer overflow in expression of type ‘int’ results in ‘-2147483648’ [-Woverflow]
    6 |     int b = INT_MAX + 1;
      |                     ^
estouro.cpp:8:15: warning: overflow in conversion from ‘int’ to ‘short int’ changes value from ‘70000’ to ‘4464’ [-Woverflow]
    8 |     short d = 70000;
      |               ^~~~~
$ ./estouro
-1294967296 -2147483648 4294967295 4464

• int a = 3000000000; virou −1294967296 sem aviso com -Wall -Wextra. Só a opção -Wconversion pega: warning: conversion from ‘long int’ to ‘int’ changes value from ‘3000000000’ to ‘-1294967296’ [-Wconversion].
• INT_MAX + 1 com int é comportamento indefinido. Aqui, como é uma conta feita na compilação, o g++ avisou (-Woverflow); numa conta com variáveis, não avisaria.
• unsigned c = -1; vale 4294967295, sem aviso: em unsigned as contas "dão a volta" (aritmética módulo 2³²), e isso é definido. Do mesmo jeito, 0u - 1 dá 4294967295.
• short d = 70000; virou 4464 (70000 − 65536), com aviso.

3. Com chaves, o compilador recusa. A inicialização com {} não aceita conversões que perdem valor (narrowing, "estreitamento"):

int main() {
    int a{3000000000};
    return a;
}

$ g++ -std=c++23 -Wall -Wextra chaves.cpp -o chaves
chaves.cpp: In function ‘int main()’:
chaves.cpp:2:11: error: narrowing conversion of ‘3000000000’ from ‘long int’ to ‘int’ [-Wnarrowing]
    2 |     int a{3000000000};
      |           ^~~~~~~~~~

Um bom motivo para preferir int a{…};. Veja Variáveis e Conversão de Tipos.

4. Divisão de inteiros. 7 / 2 dá 3, e -7 / 2 dá -3 (corta para o lado do zero); -7 % 2 dá -1. Com um dos lados double, 7 / 2.0 dá 3.5. Veja Operadores Aritméticos.

5. Comparar com e sem sinal. -1 < 0u é false: o −1 é convertido para unsigned e vira 4294967295. Por isso o -Wall avisa em i < v.size() com int i (-Wsign-compare).