0Pricing
C++ Academy · Aula

Tipos inteiros versus ponto flutuante

Escolha o tipo numérico adequado compreendendo os compromissos entre tamanhos, intervalos e precisão

Tipos inteiros versus ponto flutuante é uma aula grátis de C++ Academy no CoddyKit. Esta é a aula 1 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de C++ Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de C++ Academy inclui 4 aulas no total.

Dois mundos numéricos

O C++ tem duas famílias de tipos numéricos: inteiros (sem frações, exatos) e ponto flutuante (aproximados, com frações). Escolha a família certa para cada tarefa.

Tipos inteiros

Tipos inteiros integrados e tamanhos típicos em sistemas de 64 bits:

  • char — 1 byte
  • short — 2 bytes
  • int — 4 bytes
  • long — 4 ou 8 bytes
  • long long — 8 bytes

Com sinal versus sem sinal

Adicione unsigned para eliminar o intervalo negativo. A aritmética sem sinal dá a volta usando o módulo 2^N — às vezes isso é útil, mas geralmente é uma armadilha.

unsigned int u = 0;
u -= 1;  // wraps around to 4,294,967,295

Inteiros de largura fixa

Use os tipos de <cstdint> quando precisar de tamanhos exatos — para protocolos, formatos de arquivo ou portabilidade entre plataformas.

#include <cstdint>
int8_t   tiny  = 100;
int32_t  word  = 100000;
int64_t  big   = 1LL << 40;
uint64_t huge  = 18446744073709551615ULL;

Tipos de ponto flutuante

Três tipos de ponto flutuante com precisão crescente:

  • float — 32 bits, cerca de 7 dígitos decimais
  • double — 64 bits, cerca de 15 dígitos decimais
  • long double — normalmente 80 ou 128 bits

Formato IEEE 754

Os números de ponto flutuante seguem o padrão IEEE 754: sinal, expoente e mantissa. Eles podem representar valores muito grandes e muito pequenos, mas não com exatidão.

Armadilhas do ponto flutuante

A maioria dos números decimais não pode ser representada exatamente em binário. 0.1 + 0.2 não é exatamente 0.3.

double sum = 0.1 + 0.2;
std::cout << (sum == 0.3);   // false on most systems
std::cout << sum;            // 0.3 but printed approximately

Comparando números de ponto flutuante com segurança

Nunca compare números de ponto flutuante com ==. Compare dentro de uma pequena tolerância (épsilon).

bool approxEqual(double a, double b, double eps = 1e-9) {
    return std::abs(a - b) < eps;
}

Valores especiais de ponto flutuante

Números de ponto flutuante têm três valores especiais: NaN (não é um número), +inf e -inf. Use os predicados de <cmath> para verificá-los.

#include <cmath>
double x = std::sqrt(-1.0);
if (std::isnan(x)) std::cout << "Not a number";
if (std::isinf(x)) std::cout << "Infinity";

Quando usar cada tipo

Escolha conforme o domínio:

  • Contagens e índices → int ou size_t
  • Cálculos científicos ou gráficos → double
  • Dinheiro → nunca double! Use inteiros em escala (centavos) ou uma biblioteca decimal

Os tamanhos dos tipos variam conforme a plataforma

O padrão garante apenas tamanhos mínimos. int pode ter 16, 32 ou 64 bits. Para obter portabilidade, use tipos de largura fixa de <cstdint> nas estruturas de dados.

Verificação rápida

Qual tipo você deve usar para representar valores monetários com precisão?

Recapitulação

Inteiros são exatos; números de ponto flutuante são aproximados. Escolha int ou inteiros de largura fixa para contagens, double para cálculos científicos e nunca use números de ponto flutuante para dinheiro. Compare-os com uma tolerância, nunca com ==.

Perguntas Frequentes

A aula “Tipos inteiros versus ponto flutuante” é grátis?

Sim — o texto completo de “Tipos inteiros versus ponto flutuante” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de C++ Academy, atualize para CoddyKit PRO. O curso de C++ Academy inclui 4 aulas no total.

O que vou aprender em “Tipos inteiros versus ponto flutuante”?

Escolha o tipo numérico adequado compreendendo os compromissos entre tamanhos, intervalos e precisão Você pratica C++ Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar C++ Academy?

Nenhuma experiência prévia é necessária. C++ Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 1 de 4.

Quanto tempo leva a aula “Tipos inteiros versus ponto flutuante”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de C++ Academy?

Sim. Cada aula de C++ Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

  1. Tipos inteiros versus ponto flutuante
  2. O cabeçalho cmath: pow, sqrt, abs, round
  3. Números aleatórios com o cabeçalho random
  4. Limites numéricos e comportamento de overflow
← Voltar para C++ Academy