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

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

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时，&0语法可以正常工作。编辑: 不，它没有。不好意思。

编辑:

显然我的问题太模棱两可了。我正在寻找一种方法来 字面意思一个 *int64。这可以在构造函数中使用，也可以用来表示文本结构值，甚至可以作为其他函数的参数。但助手函数或使用不同的类型不是我要寻找的解决方案。

114160 次浏览
小开
最佳答案

Go 语言规范(地址运算符)不允许获取数值常量(不是 无法打印常量，也不是 打好了常量)的地址。

操作数必须是 可寻址的，即变量、指针间接或片索引操作; 或可寻址结构操作数的字段选择器; 或可寻址数组的数组索引操作。作为可寻址性要求的一个例外，x[在 &x的表达式中]也可能是(可能括号中的) 复合文字。

有关为什么不允许这样做的原因，请参阅相关问题: 在去找常数的地址。一个类似的问题(同样不允许采取其地址) : 如何在 Go 中存储对操作结果的引用？

0)通用解决方案(由 Go 1.18开始)

在 Go 1.18中添加了泛型。这意味着我们可以创建一个单独的、通用的 Ptr()函数，它返回一个指向我们传递给它的任何值的指针。希望它能被添加到标准库中。在那之前，您可以使用 github.com/icza/gog，gog.Ptr()函数(公开: 我是作者)。

这就是它看起来的样子:

func Ptr[T any](v T) *T {
return &v
}

测试:

i := Ptr(2)
log.Printf("%T %v", i, *i)


s := Ptr("abc")
log.Printf("%T %v", s, *s)


x := Ptr[any](nil)
log.Printf("%T %v", x, *x)

它将输出(在 去游乐场上试试) :

2009/11/10 23:00:00 *int 2
2009/11/10 23:00:00 *string abc
2009/11/10 23:00:00 *interface {} <nil>

其他选项(在 Go 1.18之前)(在 去游乐场上尝试所有选项) :

1)与 new()合作

您可以简单地使用内置的 new()函数来分配一个新的零值 int64并获得它的地址:

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

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

2)使用 helper 变量

对于非零元素，最简单和推荐的方法是使用一个 helper 变量，它的地址可以采用:

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

3)具有辅助功能

注意: Helper 函数可以获得指向非零值的指针，在我的 github.com/icza/gox库中，在 gox包中，所以你不必将它们添加到所有你需要的项目中。

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

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

使用它:

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

请注意，我们实际上没有分配任何东西，当我们返回函数参数的地址时，Go 编译器就这样做了。Go 编译器执行转义分析，如果局部变量可以转义函数，则在堆上(而不是堆栈上)分配局部变量。有关详细信息，请参阅 在 Go 函数中返回局部数组的一个片是否安全？

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)使用 helper 结构文字

让我们研究一下可寻址性需求的异常:

作为可寻址性要求的一个例外，x[在 &x的表达式中]也可能是(可能括号中的) 复合文字。

这意味着获取复合文字的地址，例如 struct 文字就可以了。如果这样做，我们将分配结构值并获得指向它的指针。但是，如果是这样，另一个需求将成为可用于我们: “可寻址结构操作数的字段选择器”。因此，如果 struct 文字包含 int64类型的字段，我们也可以获取该字段的地址！

让我们看看这个选项是如何工作的。我们将使用这个包装器结构类型:

type intwrapper struct {
x int64
}

现在我们可以做:

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

注意这个

&(&intwrapper{6}).x

指下列各项:

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

但是我们可以省略“外部”括号，因为地址运算符 &被应用于 选择器表达式的结果。

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

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

7)使用 helper 匿名结构文字

其原理与案例 # 6相同，但我们也可以使用匿名结构文字，因此不需要助手/包装器结构类型定义:

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

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

在下面的代码中，我们使用函数 f，它接受一个整数和 返回一个包含整数地址的指针值。用这种方法我们可以很容易地解决上述问题。

type myStr struct {
url *int64
}


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

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

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

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",
)
// ...
}
小开

如果您不介意使用第三方库，那么有一个使用泛型(go 1.18 +)的 瞧包，它具有 .ToPtr()函数

ptr := lo.ToPtr("hello world")
// *string{"hello world"}

提交答案