如何为无符号整数类型指定可表示的最大值?
我想知道如何在下面的循环中初始化min，迭代计算一些结构的min和max长度。
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。
当前回答
解决这个问题的一种方法是从值本身获取起始点:
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 }
}
}
其他回答
Go 1.17(2021年第四季度)可能会有所帮助，提交e8eb1d8，正如Go101所指出的:
在Go 1.17之前，我们可以使用下面的技巧来定义MaxInt: const MaxInt = int(^uint(0) >> 1) 从Go 1.17开始，我们可以直接使用数学。MaxInt相反
修复了Silentd00m报告的问题28538，并使用CL 247058进行了审查。
由于我们有int8到int64 min max和uint8到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)
}
Go-1.17现在在数学包中定义了MaxInt, MaxInt和MinInt常量。
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
数学包现在又定义了三个常量:MaxInt、MaxInt和MinInt。 对于32位系统，它们的值分别是2^32 - 1,2 ^31 - 1和-2^31。 对于64位系统，它们的值分别是2^64 - 1,2 ^63 - 1和-2^63。
提交: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
一个轻量级包包含了它们(以及其他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
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
解决这个问题的一种方法是从值本身获取起始点:
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 }
}
}
