我一直在读这个post on constants in Go ，我正在尝试了解它们在内存中的存储和使用方式。您可以在 Go 中对非常大的常量执行操作，只要结果适合内存，您就可以将该结果强制转换为一个类型。例如，这段代码打印 10，如您所料:

const Huge = 1e1000
fmt.Println(Huge / 1e999)

这是如何运作的？在某些时候，Go 必须将 1e1000 和 1e999 存储在内存中，以便对它们执行操作。那么常量是如何存储的，Go 又是如何对它们进行运算的呢？

最佳答案

简短摘要 (TL;DR) 在答案的末尾。

无类型的任意精度常量在运行时不存在，常量仅在编译时(编译期间)存在。也就是说，Go 不必在运行时以任意精度表示常量，仅在编译您的应用程序时才可以。

为什么？因为常量不会被编译成可执行二进制文件。他们不必如此。让我们举个例子:

const Huge = 1e1000
fmt.Println(Huge / 1e999)

源代码 中有一个常量Huge(并且会在包对象中)，但它不会出现在您的可执行文件中。相反，对 fmt.Println() 的函数调用将被记录为传递给它的值，其类型将为 float64。因此，在可执行文件中，只会记录 float64 值为 10.0 的值。可执行文件中没有任何数字为 1e1000 的迹象。

此float64 类型派生自untyped 常量Huge 的默认 类型。 1e1000 是 floating-point literal .验证它:

const Huge = 1e1000
x := Huge / 1e999
fmt.Printf("%T", x) // Prints float64

回到任意精度:

Spec: Constants:

Numeric constants represent exact values of arbitrary precision and do not overflow.

所以常量表示任意精度的精确值。正如我们所见，没有必要在运行时 以任意精度表示常量，但编译器仍然需要在编译时 做一些事情。它确实!

显然无法处理“无限”精度。但是没有必要，因为源代码本身不是“无限的”(源代码的大小是有限的)。不过，允许真正任意的精度是不切实际的。因此，规范在这方面为编译器提供了一些自由:

Implementation restriction: Although numeric constants have arbitrary precision in the language, a compiler may implement them using an internal representation with limited precision. That said, every implementation must:

• Represent integer constants with at least 256 bits.
• Represent floating-point constants, including the parts of a complex constant, with a mantissa of at least 256 bits and a signed exponent of at least 32 bits.
• Give an error if unable to represent an integer constant precisely.
• Give an error if unable to represent a floating-point or complex constant due to overflow.
• Round to the nearest representable constant if unable to represent a floating-point or complex constant due to limits on precision. These requirements apply both to literal constants and to the result of evaluating constant expressions.

但是，还要注意，当上述所有内容都说明时，标准包为您提供了仍然以“任意”精度表示和使用值(常量)的方法，请参见包 go/constant .您可以查看其源代码以了解其实现方式。

实现在 go/constant/value.go 中.表示此类值的类型:

// A Value represents the value of a Go constant.
type Value interface {
    // Kind returns the value kind.
    Kind() Kind

    // String returns a short, human-readable form of the value.
    // For numeric values, the result may be an approximation;
    // for String values the result may be a shortened string.
    // Use ExactString for a string representing a value exactly.
    String() string

    // ExactString returns an exact, printable form of the value.
    ExactString() string

    // Prevent external implementations.
    implementsValue()
}

type (
    unknownVal struct{}
    boolVal    bool
    stringVal  string
    int64Val   int64                    // Int values representable as an int64
    intVal     struct{ val *big.Int }   // Int values not representable as an int64
    ratVal     struct{ val *big.Rat }   // Float values representable as a fraction
    floatVal   struct{ val *big.Float } // Float values not representable as a fraction
    complexVal struct{ re, im Value }
)

如您所见，math/big包用于表示无类型的任意精度值。 big.Int例如(来自 math/big/int.go ):

// An Int represents a signed multi-precision integer.
// The zero value for an Int represents the value 0.
type Int struct {
    neg bool // sign
    abs nat  // absolute value of the integer
}

nat 在哪里(来自 math/big/nat.go ):

// An unsigned integer x of the form
//
//   x = x[n-1]*_B^(n-1) + x[n-2]*_B^(n-2) + ... + x[1]*_B + x[0]
//
// with 0 <= x[i] < _B and 0 <= i < n is stored in a slice of length n,
// with the digits x[i] as the slice elements.
//
// A number is normalized if the slice contains no leading 0 digits.
// During arithmetic operations, denormalized values may occur but are
// always normalized before returning the final result. The normalized
// representation of 0 is the empty or nil slice (length = 0).
//
type nat []Word

最后 Word是(来自math/big/arith.go)

// A Word represents a single digit of a multi-precision unsigned integer.
type Word uintptr

总结

在运行时:预定义 类型提供有限的精度，但您可以使用某些包“模仿”任意精度，例如 math/big 和 go/constant 。在编译时:常量看似提供任意精度，但实际上编译器可能达不到这一点(不必)；但规范仍然为所有编译器必须支持的常量提供最低精度，例如整数常量必须至少用 256 位表示，即 32 字节(与“仅”8 字节的 int64 相比)。

创建可执行二进制文件时，常量表达式(具有任意精度)的结果必须转换并用有限精度类型的值表示——这可能是不可能的，因此可能会导致编译时错误。请注意，只有结果 - 而不是中间操作数 - 必须转换为有限精度，常量运算以任意精度执行。

如何实现这种任意或增强的精度未由规范定义，math/big 例如将数字的“数字”存储在 slice 中(其中数字不是基数的数字10 表示，但“数字”是 uintptr，它类似于 32 位架构上的基本 4294967295 表示，在 64 位架构上甚至更大)。

关于go - Go 如何对常量进行算术运算？，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/38982278/