如何为无符号整数类型指定可表示的最大值?
我想知道如何在下面的循环中初始化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。
当前回答
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)
}
其他回答
https://groups.google.com/group/golang-nuts/msg/71c307e4d73024ce?pli=1
相关部分:
由于整数类型使用二补运算，因此可以推断 int和uint的最小/最大常量值。例如, const maxint = ^uint(0) const MinUint = 0 const MaxInt = int(MaxInt >> 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
一个轻量级包包含了它们(以及其他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
我一直记得的方法是，取比特(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
}
}
解决这个问题的一种方法是从值本身获取起始点:
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 }
}
}
来自数学库: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)
}
