Go 中 int 类型的最大值

Question

如何指定无符号整数类型可表示的最大值？

我想知道如何在下面的循环中初始化 min ，该循环迭代地计算某些结构的最小和最大长度。

var minLen uint = ???
var maxLen uint = 0
for _, thing := range sliceOfThings {
  if minLen > thing.n { minLen = thing.n }
  if maxLen < thing.n { maxLen = thing.n }
}
if minLen > maxLen {
  // If there are no values, clamp min at 0 so that min <= max.
  minLen = 0
}

这样第一次比较时，minLen >= n。

Answer 1

https://groups.google.com/group/golang-nuts /msg/71c307e4d73024ce?pli=1

相关部分：

由于整数类型使用二进制补码算术，因此您可以推断出
int 和 uint 的最小/最大常量值。例如，

const MaxUint = ^uint(0) 
常量 MinUint = 0 
const MaxInt = int(MaxUint >> 1) 
const MinInt = -MaxInt - 1

根据 @CarelZA 的评论：

uint8  : 0 to 255 
uint16 : 0 to 65535 
uint32 : 0 to 4294967295 
uint64 : 0 to 18446744073709551615 
int8   : -128 to 127 
int16  : -32768 to 32767 
int32  : -2147483648 to 2147483647 
int64  : -9223372036854775808 to 9223372036854775807

Answer 2

https://golang.org/ref/spec#Numeric_types 了解物理类型限制。

最大值在 math 包中定义，因此在您的情况下： math.MaxUint32

小心，因为没有溢出 - 增加超过最大值会导致环绕。

Answer 3

我将使用 math 包来获取整数的最大值和最小值：

package main

import (
    "fmt"
    "math"
)

func main() {
    // integer max
    fmt.Printf("max int64   = %+v\n", math.MaxInt64)
    fmt.Printf("max int32   = %+v\n", math.MaxInt32)
    fmt.Printf("max int16   = %+v\n", math.MaxInt16)

    // integer min
    fmt.Printf("min int64   = %+v\n", math.MinInt64)
    fmt.Printf("min int32   = %+v\n", math.MinInt32)

    fmt.Printf("max float64 = %+v\n", math.MaxFloat64)
    fmt.Printf("max float32 = %+v\n", math.MaxFloat32)

    // etc you can see more int the `math`package
}

输出：

max int64   = 9223372036854775807
max int32   = 2147483647
max int16   = 32767
min int64   = -9223372036854775808
min int32   = -2147483648
max float64 = 1.7976931348623157e+308
max float32 = 3.4028234663852886e+38

Answer 4

注意：此答案自 go 1.17 起被取代，其中包括 e8eb1d8；即：math 包现在包含 math.MaxUint、math.MaxInt 和 math.MinInt 常量。

简单总结：

import "math/bits"
const (
    MaxUint uint = (1 << bits.UintSize) - 1
    MaxInt int = (1 << bits.UintSize) / 2 - 1
    MinInt int = (1 << bits.UintSize) / -2
)

背景：

我想您知道，uint 类型的大小与 uint32 或 uint64 相同，具体取决于在平台上你在。通常，只有在不存在接近最大值的风险时，人们才会使用这些的未调整大小的版本，因为没有大小规范的版本可以使用“本机”类型，具体取决于平台，这往往会更快。

请注意，它往往“更快”，因为使用非本机类型有时需要处理器执行额外的数学和边界检查，以便模拟更大或更小的整数。考虑到这一点，请注意处理器（或编译器的优化代码）的性能几乎总是比添加您自己的边界检查代码更好，因此如果存在任何发挥作用的风险，可能会导致明智的做法是简单地使用固定大小的版本，并让优化的仿真处理由此产生的任何后果。

话虽如此，在某些情况下，了解您正在处理的内容仍然很有用。

包“math/bits”包含 uint< 的大小/code>，以位为单位。要确定最大值，请将 1 移动相应位数，再减 1。即：(1 << bits.UintSize) - 1

请注意，计算最大值时uint 的值，通常需要将其显式放入 uint （或更大）变量中，否则编译器可能会失败，因为它会默认尝试分配将该计算转化为有符号的int （显然，它不适合），所以：

const MaxUint uint = (1 << bits.UintSize) - 1

这是您问题的直接答案，但还有一些您可能感兴趣的相关计算。

根据spec、uint 和 int 始终相同的尺寸。

uint 32 或 64 位

int 大小与 uint

所以我们也可以使用此常量来确定 int 的最大值，方法是采用相同的答案并除以 2，然后减去 1。即： (1 << bits.UintSize) / 2 - 1

以及 int 的最小值，通过将 1 移位那么多位并将结果除以 -2。即：(1 <

总结：

MaxUint: (1 <

MaxInt: (1 << bits.UintSize) / 2 - 1

MinInt: (1 <

完整示例 (应该和下面一样)

package main

import "fmt"
import "math"
import "math/bits"

func main() {
    var mi32 int64 = math.MinInt32
    var mi64 int64 = math.MinInt64
    
    var i32 uint64 = math.MaxInt32
    var ui32 uint64 = math.MaxUint32
    var i64 uint64 = math.MaxInt64
    var ui64 uint64 = math.MaxUint64
    var ui uint64 = (1 << bits.UintSize) - 1
    var i uint64 = (1 << bits.UintSize) / 2 - 1
    var mi int64 = (1 << bits.UintSize) / -2
    
    fmt.Printf(" MinInt32: %d\n", mi32)
    fmt.Printf(" MaxInt32:  %d\n", i32)
    fmt.Printf("MaxUint32:  %d\n", ui32)
    fmt.Printf(" MinInt64: %d\n", mi64)
    fmt.Printf(" MaxInt64:  %d\n", i64)
    fmt.Printf("MaxUint64:  %d\n", ui64)
    fmt.Printf("  MaxUint:  %d\n", ui)
    fmt.Printf("   MinInt: %d\n", mi)
    fmt.Printf("   MaxInt:  %d\n", i)
}

Answer 5

我最初使用的是从 @nmichaels 在他的答案中使用的讨论线程中获取的代码。我现在使用稍微不同的计算。我已经添加了一些评论，以防其他人有与 @Arijoon 相同的查询。

const (
    MinUint uint = 0                 // binary: all zeroes

    // Perform a bitwise NOT to change every bit from 0 to 1
    MaxUint      = ^MinUint          // binary: all ones

    // Shift the binary number to the right (i.e. divide by two)
    // to change the high bit to 0
    MaxInt       = int(MaxUint >> 1) // binary: all ones except high bit

    // Perform another bitwise NOT to change the high bit to 1 and
    // all other bits to 0
    MinInt       = ^MaxInt           // binary: all zeroes except high bit
)

最后两个步骤之所以有效，是因为正数和负数在二进制补码算术中的表示方式。 数字类型 上的 Go 语言规范部分将读者引向相关的维基百科文章。我还没读过，但我确实从 Charles Petzold 的 Code by Charles Petzold 书中了解了二进制补码，这是对计算机和编码基础知识的简单易懂的介绍。

我将上面的代码（减去大部分注释）放入一个小整数数学包中。

Answer 6

Go-1.17 现在在 数学 包。

package main

import "fmt"
import "math"

const maxUint = uint(math.MaxUint)

func main() {
    fmt.Println("Integer range on your system")

    // .Println("MaxUint:", math.MaxUint)  ERROR constant 18446744073709551615 overflows int
    fmt.Println("MaxUint:", maxUint)

    fmt.Println("MinInt:", math.MinInt)
    fmt.Println("MaxInt:", math.MaxInt)
}

• 测试上面的代码：https://play.golang.org/p/5R2iPasn6OZ

• 来自 Go 1.17 发行说明：https://golang.org/doc/go1.17#math

数学包现在又定义了三个常量：MaxUint、MaxInt 和 MinInt。
对于 32 位系统，它们的值分别为 2^32 - 1、2^31 - 1 和 -2^31。
对于 64 位系统，它们的值分别为 2^64 - 1、2^63 - 1 和 -2^63。 p>

• 提交：https://github.com/golang/go/commit/e8eb1d82
• 文档： https://pkg.go.dev/math#pkg-constants

const (
    MaxInt    = 1<<(intSize-1) - 1   // New
    MinInt    = -1 << (intSize - 1)  // New
    MaxInt8   = 1<<7 - 1
    MinInt8   = -1 << 7
    MaxInt16  = 1<<15 - 1
    MinInt16  = -1 << 15
    MaxInt32  = 1<<31 - 1
    MinInt32  = -1 << 31
    MaxInt64  = 1<<63 - 1
    MinInt64  = -1 << 63
    MaxUint   = 1<<intSize - 1       // New
    MaxUint8  = 1<<8 - 1
    MaxUint16 = 1<<16 - 1
    MaxUint32 = 1<<32 - 1
    MaxUint64 = 1<<64 - 1
)

另请参阅Go 源代码： https://github.com/ golang/go/blob/master/src/math/const.go#L39

Answer 7

来自数学库： https://github.com/golang /go/blob/master/src/math/const.go#L39

package main

import (
    "fmt"
    "math"
)

func main() {
    fmt.Printf("max int64: %d\n", math.MaxInt64)
}

Answer 8

使用数学包中定义的常量：

const (
    MaxInt8   = 1<<7 - 1
    MinInt8   = -1 << 7
    MaxInt16  = 1<<15 - 1
    MinInt16  = -1 << 15
    MaxInt32  = 1<<31 - 1
    MinInt32  = -1 << 31
    MaxInt64  = 1<<63 - 1
    MinInt64  = -1 << 63
    MaxUint8  = 1<<8 - 1
    MaxUint16 = 1<<16 - 1
    MaxUint32 = 1<<32 - 1
    MaxUint64 = 1<<64 - 1
)

Answer 9

解决此问题的一种方法是从值本身获取起点：

var minLen, maxLen uint
if len(sliceOfThings) > 0 {
  minLen = sliceOfThings[0].minLen
  maxLen = sliceOfThings[0].maxLen
  for _, thing := range sliceOfThings[1:] {
    if minLen > thing.minLen { minLen = thing.minLen }
    if maxLen < thing.maxLen { maxLen = thing.maxLen }
  }
}

Answer 10

Go 1.17（2021 年第 4 季度）可能会有所帮助，提交 e8eb1d8，如 Go101：

在Go 1.17之前，我们可以使用以下技巧来定义MaxInt：

const MaxInt = int(^uint(0) >> 1)

从 Go 1.17 开始，我们可以直接使用 math.MaxInt 代替

这修复了 问题 28538 由 Silentd00m，由 CL 247058。

因为我们有 int8 到 int64 min max 和 uint8 到 < code>uint64 max 常量，我们可能也应该有一些用于字大小类型的常量。

测试说明了其工作原理：

    if v := int(MaxInt); v+1 != MinInt {
        t.Errorf("MaxInt should wrap around to MinInt: %d", v+1)
    }
    if v := int8(MaxInt8); v+1 != MinInt8 {
        t.Errorf("MaxInt8 should wrap around to MinInt8: %d", v+1)
    }
    if v := int16(MaxInt16); v+1 != MinInt16 {
        t.Errorf("MaxInt16 should wrap around to MinInt16: %d", v+1)
    }
    if v := int32(MaxInt32); v+1 != MinInt32 {
        t.Errorf("MaxInt32 should wrap around to MinInt32: %d", v+1)
    }
    if v := int64(MaxInt64); v+1 != MinInt64 {
        t.Errorf("MaxInt64 should wrap around to MinInt64: %d", v+1)
    }

Answer 11

MaxInt8   = 1<<7 - 1
MinInt8   = -1 << 7
MaxInt16  = 1<<15 - 1
MinInt16  = -1 << 15
MaxInt32  = 1<<31 - 1
MinInt32  = -1 << 31
MaxInt64  = 1<<63 - 1
MinInt64  = -1 << 63
MaxUint8  = 1<<8 - 1
MaxUint16 = 1<<16 - 1
MaxUint32 = 1<<32 - 1
MaxUint64 = 1<<64 - 1

Answer 12

我一直记得的方式是，你取位（int8 是 8 位，int 是
32 位），除以 8 即可得到字节（int8 是一个字节，int
将是四个字节）。

每个字节都是0xFF（有符号整数除外，在这种情况下最高有效字节）
字节将为0x7F）。这是结果：

package main

func main() {
   {
      var n int8 = 0x7F
      println(n) // 127
   }
   {
      var n uint8 = 0xFF
      println(n) // 255
   }
   {
      var n int = 0x7FFF_FFFF
      println(n) // 2147483647
   }
   {
      var n uint = 0xFFFF_FFFF
      println(n) // 4294967295
   }
}

Answer 13

一个轻量级的 package 包含它们（以及其他 int 类型限制和一些广泛使用的整数）功能）：

import (
    "fmt"
    "<Full URL>/go-imath/ix"
    "<Full URL>/go-imath/ux"
)
...
fmt.Println(ix.Minimal) // Output: -2147483648 (32-bit) or -9223372036854775808 (64-bit)
fmt.Println(ix.Maximal) // Output: 2147483647 or 9223372036854775807
fmt.Println(ux.Minimal) // Output: 0
fmt.Println(ux.Maximal) // Output: 4294967295 or 18446744073709551615