Por que não existe INT_MAX em Go e como isso afeta o desempenho

Paradoxo: não existe INT_MAX em Go, mas isso não é um problema

Se você veio para Go vindo do mundo C++, Java ou Python, certamente já se deparou com a situação de precisar saber o valor máximo de um número inteiro. Em C++ existe INT_MAX, em Python os limites são dinâmicos, e em Go... você terá uma surpresa. Na biblioteca padrão não existe uma constante do tipo IntMax ou MaxInt para o tipo comum int. E isso não é um bug, mas uma funcionalidade que afeta diretamente o desempenho do seu código.

A pergunta "The maximum value for an int type in Go" no Stack Overflow acumulou milhares de visualizações. Desenvolvedores buscam a resposta, mas muitas vezes não entendem por que Go é projetado dessa forma. Vamos entender isso de uma vez por todas, e também descobrir como conhecer os limites dos números inteiros ajuda a escrever programas mais rápidos e seguros.

Resposta curta: como obter o máximo para int em Go

Se você precisa apenas do número — use as constantes do pacote math:

package main\n\nimport (\n    "fmt"\n    "math"\n)\n\nfunc main() {\n    // Para int32 e int64 é simples\n    fmt.Println("Max int32:", math.MaxInt32)   // 2147483647\n    fmt.Println("Min int32:", math.MinInt32)   // -2147483648\n    fmt.Println("Max int64:", math.MaxInt64)   // 9223372036854775807\n    fmt.Println("Min int64:", math.MinInt64)   // -9223372036854775808\n\n    // E com o int comum?\n    // Não existe constante math.MaxInt!\n}

Viu? Para int32 e int64 existem constantes, mas para int — não. Por quê? Porque int é um tipo dependente de plataforma. Em sistemas de 32 bits, ele equivale a int32; em sistemas de 64 bits, a int64. Criar uma constante única significaria quebrar a abstração da plataforma. Go prefere a explicitude.

Gambiarra para preguiçosos: calculando MaxInt em tempo real

Mas se você realmente precisar, é possível calcular o valor máximo programaticamente (embora seja considerada uma má prática):

package main\n\nimport (\n    "fmt"\n    "math"\n)\n\nfunc main() {\n    // Gambiarra: usando deslocamento de bits\n    const MaxUint = ^uint(0)\n    const MaxInt = int(MaxUint >> 1)\n    const MinInt = -MaxInt - 1\n\n    fmt.Println("Max int:", MaxInt)   // 9223372036854775807 (em 64-bit)\n    fmt.Println("Min int:", MinInt)   // -9223372036854775808\n\n    // Verificando: é igual a math.MaxInt64?\n    fmt.Println("São iguais?", MaxInt == math.MaxInt64) // true em 64-bit\n}

Isso funciona assim: ^uint(0) gera um número composto apenas por bits 1 (máximo para uint). O deslocamento à direita em um bit o transforma no valor máximo para int (remove o bit de sinal).

Por que isso é importante para o desempenho?

Agora vamos ao mais interessante — a otimização. Conhecer os limites dos números inteiros em Go é crucial quando você escreve código de alta carga. Aqui estão três cenários onde isso se manifesta.

1. Evitando verificações desnecessárias de estouro

Go não gera pânico em caso de integer overflow (estouro de inteiros) — o valor simplesmente "dá a volta". Isso foi feito intencionalmente em prol do desempenho. Mas se você não conhece os limites, pode acabar com um bug difícil de detectar.

package main\n\nimport "fmt"\n\nfunc main() {\n    var a int8 = 127\n    a++\n    fmt.Println(a) // -128 — estouro sem erro!\n\n    // Se você estiver escrevendo um contador, controle os limites\n    for i := 0; i < 1000; i++ {\n        // Se i for int8, será um loop infinito (estouro)\n    }\n}

Dica de otimização: se você sabe com certeza que o valor não ultrapassa math.MaxInt32, use int32 em vez de int. Em sistemas de 64 bits, isso pode economizar memória em slices e structs, e em sistemas de 32 bits, acelerar a aritmética.

2. Benchmark: int contra int32 em 64-b