0Pricing
C++ Academy · Aula

Limites numéricos e comportamento de overflow

Consulte std::numeric_limits e compreenda as regras de overflow com e sem sinal

Limites numéricos e comportamento de overflow é uma aula grátis de C++ Academy no CoddyKit. Esta é a aula 4 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.

Por que os limites são importantes

Todo tipo numérico tem um maior e um menor valor representável. Ultrapassá-los pode produzir silenciosamente resultados incorretos — ou comportamento indefinido.

std::numeric_limits

Consulte os limites de qualquer tipo numérico com o cabeçalho <limits>. São constantes determinadas em tempo de compilação — sem custo em tempo de execução.

#include <limits>
std::cout << std::numeric_limits<int>::max() << "\n";
std::cout << std::numeric_limits<int>::min() << "\n";
std::cout << std::numeric_limits<double>::epsilon();

Consultas comuns

Os membros mais úteis:

  • max() — maior valor
  • min() — menor valor (positivo)
  • lowest() — valor mais negativo
  • epsilon() — menor diferença significativa (para números de ponto flutuante)
  • digits10 — algarismos decimais garantidos

Estouro de inteiros com sinal

O estouro de inteiros com sinal é um comportamento indefinido. O compilador pode presumir que isso nunca acontece, levando a otimizações surpreendentes.

int x = std::numeric_limits<int>::max();
x += 1;   // UB — anything can happen

Estouro de inteiros sem sinal

O estouro de inteiros sem sinal é definido — os valores dão a volta usando o módulo 2^N. Isso às vezes é útil, mas frequentemente é uma armadilha.

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

Estouro e subfluxo de números de ponto flutuante

Números de ponto flutuante sofrem estouro para inf em vez de causar uma falha. O subfluxo resulta em números subnormais ou em 0.

double x = 1e308;
x *= 100;
std::cout << x;  // inf

Detecção segura de estouro

Para inteiros com sinal, verifique antes da operação. Os compiladores oferecem auxiliares integrados de aritmética com verificação, como __builtin_add_overflow no GCC/Clang.

if (a > std::numeric_limits<int>::max() - b) {
    // overflow would happen
}
int sum = a + b;

std::ssize e std::cmp_less no C++20

O C++20 adiciona auxiliares seguros para comparação de inteiros em <utility>: std::cmp_equal, cmp_less e cmp_greater. Eles lidam corretamente com a mistura de inteiros com e sem sinal.

Conversões implícitas são traiçoeiras

Misturar valores com e sem sinal em uma comparação converte silenciosamente o operando com sinal para sem sinal — uma fonte comum de erros sutis.

int a = -1;
unsigned int b = 1;
if (a < b) std::cout << "yes";
else       std::cout << "no";   // prints "no"!

Verificações em tempo de compilação

Use static_assert para impor suposições sobre tamanhos ao escrever código portável.

static_assert(sizeof(int) >= 4, "Need at least 32-bit int");

Sanitizadores ajudam nos testes

Compile com -fsanitize=undefined para detectar estouros de inteiros com sinal em tempo de execução durante os testes.

g++ -fsanitize=undefined -O1 main.cpp

Verificação rápida

O que acontece quando uma adição de inteiros com sinal sofre estouro em C++?

Recapitulação

Use std::numeric_limits para consultar os limites dos tipos. O estouro com sinal é indefinido; o estouro sem sinal dá a volta. Misture valores com e sem sinal por sua conta e risco. Sanitizadores e comparações seguras do C++20 ajudam a proteger seu código.

Perguntas Frequentes

A aula “Limites numéricos e comportamento de overflow” é grátis?

Sim — o texto completo de “Limites numéricos e comportamento de overflow” é 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 “Limites numéricos e comportamento de overflow”?

Consulte std::numeric_limits e compreenda as regras de overflow com e sem sinal 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 4 de 4.

Quanto tempo leva a aula “Limites numéricos e comportamento de overflow”?

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