Golang int64 类型
最后修改时间 2025 年 5 月 8 日
本教程解释了如何在 Go 中使用内置的 int64 类型。我们将通过实际操作 64 位整数的示例来介绍类型基础知识。
int64 类型在 Go 中表示有符号的 64 位整数。它可以存储从 -263 到 263-1 的值。这个范围对于大多数大型整数计算来说是足够的。
在 Go 中，int64 是几种整数类型之一。当您需要保证 64 位存储而与平台无关时，它特别有用。
基本的 int64 声明和初始化
使用 int64 最简单的方法是声明和初始化变量。此示例展示了基本的变量声明。
注意： 显式的 int64 类型确保了 64 位大小。
basic_int64.go
package main
import "fmt"
func main() {
var a int64 = 9223372036854775807 // Maximum int64 value
var b int64 = -9223372036854775808 // Minimum int64 value
c := int64(42) // Type conversion from untyped constant
fmt.Println("a:", a)
fmt.Println("b:", b)
fmt.Println("c:", c)
}
该示例展示了创建 int64 变量的三种方法。即使在 32 位系统上，显式类型也能确保 64 位存储。
int64 的算术运算
int64 类型支持所有标准的算术运算。此示例演示了带有溢出检查的基本数学运算。
arithmetic_int64.go
package main
import (
"fmt"
"math"
)
func safeAdd(a, b int64) (int64, bool) {
if b > 0 >> a > math.MaxInt64-b {
return 0, false
}
if b < 0 >> a < math.MinInt64-b {
return 0, false
}
return a + b, true
}
func main() {
var x int64 = 5000000000000000000
var y int64 = 3000000000000000000
sum, ok := safeAdd(x, y)
if !ok {
fmt.Println("Addition would overflow")
} else {
fmt.Println("Sum:", sum)
}
product := x * 2
fmt.Println("Product:", product)
}
该示例展示了带溢出检查的安全加法。乘法演示了未经保护的标准算术运算。
int64 与其他类型之间的转换
在处理 int64 时，类型转换通常是必需的。此示例展示了 int64 与其他数字类型之间的转换。
conversions_int64.go
package main
import (
"fmt"
"math"
)
func main() {
// int to int64
var i int = 42
i64 := int64(i)
fmt.Println("int64 from int:", i64)
// float64 to int64
f := 3.14159
f64 := int64(f) // Truncates decimal part
fmt.Println("int64 from float64:", f64)
// int64 to float64
big := int64(math.MaxInt64)
bigFloat := float64(big)
fmt.Println("float64 from int64:", bigFloat)
// Check for overflow when converting
smallFloat := -9.9e18
if smallFloat < math.MinInt64 || smallFloat > math.MaxInt64 {
fmt.Println("Value out of int64 range")
} else {
fmt.Println("Safe conversion:", int64(smallFloat))
}
}
类型之间的转换必须考虑范围限制。该示例展示了带范围检查的正确转换技术。
使用 int64 进行二进制操作
int64 类型支持用于低级操作的位运算。此示例演示了常见的位操作。
bitwise_int64.go
package main
import "fmt"
func main() {
var flags int64 = 0
// Set bits
flags = flags | (1 << 5) // Set bit 5
flags = flags | (1 << 10) // Set bit 10
fmt.Printf("Flags after setting: %b\n", flags)
// Check bit
if flags&(1<<5) != 0 {
fmt.Println("Bit 5 is set")
}
// Clear bit
flags = flags &^ (1 << 5) // Clear bit 5
fmt.Printf("Flags after clearing: %b\n", flags)
// Toggle bit
flags = flags ^ (1 << 10) // Toggle bit 10
fmt.Printf("Flags after toggling: %b\n", flags)
}
位运算对于标志和紧凑数据存储非常有用。该示例展示了设置、检查、清除和切换位。
处理大的 int64 值
int64 类型可以处理非常大的数字。此示例演示了处理接近 int64 极限的值。
large_values_int64.go
package main
import (
"fmt"
"math"
)
func main() {
max := int64(math.MaxInt64)
min := int64(math.MinInt64)
fmt.Println("Maximum int64 value:", max)
fmt.Println("Minimum int64 value:", min)
// Safe operations near limits
almostMax := max - 100
fmt.Println("Almost max:", almostMax)
// Dangerous operation that would overflow
dangerous := max + 1 // This would compile but overflow
fmt.Println("Overflowed value:", dangerous)
// Proper way to check before operation
if max+1 > max {
fmt.Println("This won't print due to overflow")
} else {
fmt.Println("Overflow detected in comparison")
}
}
处理大值需要仔细的溢出检查。该示例展示了在 int64 极限附近的正确操作和危险操作。
来源
本教程通过声明、算术、转换和位操作的实际示例，涵盖了 Go 中的 int64 类型。