Максимальное значение для типа int в Go: как его получить и использовать

Использование пакета math для получения максимальных значений

В Go действительно нет единой константы INT_MAX, как в C, но разработчики предусмотрели удобный способ через пакет math. Для типов с фиксированным размером (int8, int16, int32, int64) существуют прямые константы. Для платформозависимого типа int и uint нужно использовать вычисление на основе битности.

package main

import (
    "fmt"
    "math"
    "strconv"
)

func main() {
    // Для типов с фиксированным размером
    fmt.Println("int8:", math.MaxInt8)   // 127
    fmt.Println("int16:", math.MaxInt16) // 32767
    fmt.Println("int32:", math.MaxInt32) // 2147483647
    fmt.Println("int64:", math.MaxInt64) // 9223372036854775807

    // Для uint
    fmt.Println("uint8:", math.MaxUint8)   // 255
    fmt.Println("uint16:", math.MaxUint16) // 65535
    fmt.Println("uint32:", math.MaxUint32) // 4294967295
    // MaxUint64 не определена из-за особенностей компиляции, но её можно вычислить
    fmt.Println("uint64:", ^uint64(0))     // 18446744073709551615

    // Для платформозависимого int используем битовый сдвиг
    // На 64-битной системе int = int64
    maxInt := int(^uint(0) >> 1)
    fmt.Println("int (текущая платформа):", maxInt)
    fmt.Println("Размер int в битах:", strconv.IntSize)
}

Почему это работает?

Тип int в Go — это знаковое целое, размер которого зависит от архитектуры: 32 бита на 32-разрядных системах и 64 бита на 64-разрядных. Выражение ^uint(0) даёт число со всеми битами, установленными в 1 (максимальное значение для uint), а сдвиг вправо на 1 бит превращает его в максимальное значение для int, так как старший бит становится нулевым (знак +).

Как избежать переполнения?

Даже если вы знаете максимальное значение, Go не генерирует ошибку при переполнении — оно просто "заворачивается". Чтобы безопасно проверить, не выйдет ли операция за пределы, используйте функции из пакета math для проверки:

package main

import (
    "fmt"
    "math"
)

func safeAdd(a, b int) (int, bool) {
    if b > 0 && a > math.MaxInt - b {
        return 0, false // переполнение
    }
    if b < 0 && a < math.MinInt - b {
        return 0, false // переполнение вниз
    }
    return a + b, true
}

func main() {
    result, ok := safeAdd(math.MaxInt32, 1)
    if !ok {
        fmt.Println("Ошибка: переполнение!")
    } else {
        fmt.Println("Результат:", result)
    }
}

Дополнительные советы

• Если вам нужны только положительные числа, используйте uint — его максимальное значение в 2 раза больше.
• Для точного контроля размера всегда используйте типы с фиксированной битностью: int32, int64.
• В Go 1.18+ появился пакет math/bits для работы с битами, но для простых проверок достаточно описанных методов.

package main

import (
    "fmt"
    "unsafe"
)

func main() {
    // Определяем размер int в байтах
    intSize := unsafe.Sizeof(int(0))
    // Максимальное значение: 2^(8*размер-1) - 1
    maxInt := (1 << (intSize*8 - 1)) - 1
    fmt.Println("Максимальное int:", maxInt)
    
    // Минимальное значение: -2^(8*размер-1)
    minInt := -(1 << (intSize*8 - 1))
    fmt.Println("Минимальное int:", minInt)
}