如何在 Go 中执行文字 *int64？

Question

我有一个带有 *int64 字段的结构类型。

type SomeType struct {
    SomeField *int64
}

在我的代码中，我想声明一个字面值（比如说，当我知道所说的值应该是 0 或指向 0 时，你知道我的意思）

instance := SomeType{
    SomeField: &0,
}

...除了这不起作用

./main.go:xx: cannot use &0 (type *int) as type *int64 in field value

所以我试试这个

instance := SomeType{
    SomeField: &int64(0),
}

...但这也行不通

./main.go:xx: cannot take the address of int64(0)

我该怎么做？我能想出的唯一解决方案是使用占位符变量

var placeholder int64
placeholder = 0

instance := SomeType{
    SomeField: &placeholder,
}

注意：&0 语法在它是 *int 而不是 *int64 时工作很好。编辑：不，它没有。对此感到抱歉。

编辑：

显然我的问题含糊不清。我正在寻找一种字面意思*int64 的方法。这可以在构造函数中使用，或者用于声明文字结构值，甚至可以作为其他函数的参数。但辅助函数或使用其他类型不是我正在寻找的解决方案。

Answer 1

还有另一种优雅的方式来实现这一点，它不会产生太多样板代码，而且在我看来也不难看。如果我需要一个带有指向原语而不是值的指针的结构，以确保在整个项目中不使用零值结构成员，我将创建一个以这些原语作为参数的函数。

您可以定义一个函数来创建您的结构，然后将原语传递给该函数，然后使用指向函数参数的指针。

type Config struct {
    Code *uint8
    Name *string
}

func NewConfig(code uint8, name string) *Config {
    return &Config{
        Code: &code,
        Name: &name,
    }
}

func UseConfig() {
    config := NewConfig(1, "test")
    // ...
}

// in case there are many values, modern IDE will highlight argument names for you, so you don't have to remember
func UseConfig2() {
    config := NewConfig(
        1,
        "test",
    )
    // ...
}

Answer 2

Go 语言规范 (Address operators) 不允许获取数字常量的地址（不是 untyped 也不是 typed 常量）。

操作数必须是可寻址的，即可以是变量、指针间接或切片索引操作；或可寻址结构操作数的字段选择器；或可寻址数组的数组索引操作。作为可寻址性要求的一个例外，x [在&x 的表达式中] 也可以是（可能用括号括起来的）composite literal。

有关不允许这样做的原因，请参阅相关问题：Find address of constant in go。一个类似的问题（同样不允许取其地址）：How can I store reference to the result of an operation in Go?

您的选择（在Go Playground 上尝试所有选项）：

1) 与new()

您可以简单地使用内置的new() 函数分配一个新的零值int64 并获取其地址：

instance := SomeType{
    SomeField: new(int64),
}

但请注意，这只能用于分配和获取指向任何类型的零值的指针。

2) 带有辅助变量

对于非零元素，最简单且推荐的方法是使用可以获取地址的辅助变量：

helper := int64(2)
instance2 := SomeType{
    SomeField: &helper,
}

3) 带辅助功能

注意：获取指向非零值的指针的辅助函数在我的 github.com/icza/gox 库中，在 gox 包中，因此您不必将这些添加到您需要的所有项目中。

或者如果您需要多次，您可以创建一个辅助函数来分配并返回一个*int64：

func create(x int64) *int64 {
    return &x
}

并使用它：

instance3 := SomeType{
    SomeField: create(3),
}

请注意，我们实际上并没有分配任何东西，Go 编译器在我们返回函数参数的地址时这样做了。 Go 编译器执行逃逸分析，如果局部变量可能逃逸函数，则在堆（而不是堆栈）上分配局部变量。详情见Is returning a slice of a local array in a Go function safe?

4) 使用单行匿名函数

instance4 := SomeType{
    SomeField: func() *int64 { i := int64(4); return &i }(),
}

或者作为（更短的）替代方案：

instance4 := SomeType{
    SomeField: func(i int64) *int64 { return &i }(4),
}

5) 使用切片文字、索引和获取地址

如果您希望 *SomeField 不是 0，那么您需要一些可寻址的东西。

你仍然可以这样做，但这很丑：

instance5 := SomeType{
    SomeField: &[]int64{5}[0],
}
fmt.Println(*instance2.SomeField) // Prints 5

这里发生的是一个[]int64 切片是用一个文字创建的，只有一个元素（5）。并对其进行索引（第 0 个元素）并获取第 0 个元素的地址。在后台，[1]int64 的数组也将被分配并用作切片的后备数组。所以这里有很多样板。

6) 使用辅助结构字面量

让我们检查一下可寻址性要求的例外情况：

作为可寻址性要求的一个例外，x [在&x 的表达式中] 也可以是（可能带括号的）composite literal。

这意味着获取复合文字的地址，例如结构文字是可以的。如果这样做，我们将分配结构值并获得指向它的指针。但如果是这样，我们将可以使用另一个要求：“可寻址结构操作数的字段选择器”。所以如果结构字面量包含int64 类型的字段，我们也可以获取该字段的地址！

让我们看看这个选项的实际效果。我们将使用这个包装器结构类型：

type intwrapper struct {
    x int64
}

现在我们可以这样做了：

instance6 := SomeType{
    SomeField: &(&intwrapper{6}).x,
}

注意这个

&(&intwrapper{6}).x

意思如下：

& ( (&intwrapper{6}).x )

但我们可以省略“外”括号，因为地址运算符& 应用于selector expression 的结果。

还要注意，在后台会发生以下情况（这也是一种有效的语法）：

&(*(&intwrapper{6})).x

7) 使用辅助匿名结构字面量

原理与案例#6相同，但我们也可以使用匿名结构体字面量，因此不需要辅助/包装结构体类型定义：

instance7 := SomeType{
    SomeField: &(&struct{ x int64 }{7}).x,
}

Answer 3

使用返回 int64 变量地址的函数来解决问题。

在下面的代码中，我们使用函数f，它接受一个整数和 返回一个指针值，它保存整数的地址。通过使用这种方法，我们可以轻松解决上述问题。

type myStr struct {
    url *int64
}

func main() {
    f := func(s int64) *int64 {
        return &s
    }
    myStr{
        url: f(12345),
    }
}