Inteiros em código são mais traiçoeiros do que parecem
Quase todo mundo que começa a programar acha que lidar com números inteiros é simples. Aritmética básica, certo? Errado. Já vi projeto inteiro quebrar porque alguém usou int em uma operação que deveria usar long, ou porque confundiu divisão inteira com divisão float sem nem perceber. Vou explicar o que dá errado na prática, não só a teoria.
probleminhas com números inteiros
O problema mais comum é o overflow. Em C e C++, se você soma dois ints grandes demais, o resultado simplesmente transborda e vira um número negativo. Em Java, ele lança exceção apenas se você usar métodos explícitos de verificação, mas no dia a dia a maioria das pessoas não coloca esses checks. Eu já perdi uma tarde inteira debuggando um cálculo de área que "funcionava" para valores pequenos e produzia resultados negativos absurdos para inputs normais de produção. O vazamento era um cálculo intermediário de tipo int que precisava ser long. O truque que eu uso agora é simples: qualquer operação que envolva potencialmente valores maiores que 10 em C/Java, eu converto para long antes. Não espera o overflow acontecer. Só converte no início da expressão. Isso resolve 80% dos bugs desse tipo.
Outro ponto que muita gente esquece: divisão inteira. Em Python, o operador // faz floor division, não truncamento para zero. Isso significa que -7 // 2 dá -4, não -3. Em C e Java, a divisão de inteiros truncam para zero, então -7 / 2 resulta em -3. Se você escreve código que precisa rodar em múltiplas linguagens ou passa dados entre elas, essa diferença já causou problemas reais de negócio em sistemas de cálculo de impostos que eu vi. Dica prática: se o seu algoritmo depende do comportamento de divisão com números negativos, sempre teste explicitamente casos negativos. Não confie que o código vai se comportar igual só porque funciona para positivos.
👉 Clique no botão abaixo para saber mais sobre o assunto!
Underflow em tipos unsigned também é pegadinha clássica. Subtrair um valor maior de um unsigned dá um número extremamente grande, não negativo. Em C++, isso é definido pelo padrão — o valor faz wraparound módulo 2^n. Já vi um sistema de contador de acessos zerar porque o código fazia uma subtração condicional sem verificar se o minuendo era menor que o subtraendo. O unsigned "estourou" e o programa continuou rodando silenciosamente com um valor completamente errado. A solução? Nunca subtraia valores unsigned sem garantir que o resultado será não-negativo, ou use comparação explícita antes da operação. Em muitos casos, converter para um tipo assinado suficiente antes da subtração evita o problema completamente.
Em Python, os inteiros têm arbitrária precisão, então overflow praticamente não existe. Mas isso cria outra armadilha: performance. Operações com ints muito grandes em Python são consideravelmente mais lentas que em linguagens com tipos fixos. Se você está fazendo milhões de operações aritméticas em loop, considerar numpy ou até migrar a parte crítica para C via ctypes ou Cython pode reduzir o tempo de execução de minutos para segundos. Modular arithmetic com números negativos é outro campo minado. Em Python, -7 % 5 retorna 3. Em C e Java, o mesmo cálculo resulta em -2. Isso estraga facilmente lógica de hash, indexação circular e algoritmos que dependem de resultados sempre positivos. Se você precisa do comportamento matemático de módulo (sempre positivo), some o divisor ao resultado antes de aplicar o módulo, ou use uma função utilitária consistentemente em todo o projeto.
Arredondamento diferente entre linguagens também causa inconsistências. O padrão IEEE 754 especifica arredondamento para o par mais próximo como default, mas implementações podem variar. Em operações que acumulam erros de ponto flutuante antes de converter para int, isso gera resultados ligeiramente diferentes entre plataformas. Se seu sistema depende de determinismo exato — como simulações financeiras ou jogos multijogador — considere usar uma biblioteca de matemática fixa ou validar os resultados em todas as plataformas alvo. Por fim, parsing de strings para inteiros. A função parseInt() em Java lança NumberFormatException se a string contiver caracteres não numéricos, espaços ou for muito longa. Em JavaScript, parseInt("42px") retorna 42 — ele para no primeiro caractere inválido. Essa diferença sutil já estragou integrações de API onde um lado enviava valores formatados e o outro esperava strings limpas. Sempre valide e limpe strings antes de converter para inteiro, e nunca confie no comportamento implícito de parsing.
Resumo prático que segue no dia a dia: use o tipo correto desde o início, verifique limites antes de operações perigosas, teste com valores negativos e extremos, e documente o comportamento esperado de divisão e módulo no seu código. Inteiros parecem triviais até o dia em que o bug aparece em produção.
