将指向局部变量的指针分配给在 Golang 中作为指针返回的结构是否安全

从现在开始，我们要努力学习啦！今天我给大家带来《将指向局部变量的指针分配给在 Golang 中作为指针返回的结构是否安全》，感兴趣的朋友请继续看下去吧！下文中的内容我们主要会涉及到等等知识点，如果在阅读本文过程中有遇到不清楚的地方，欢迎留言呀！我们一起讨论，一起学习！

我发现 golang 中的以下代码有效：

type user struct {
  name *string
  email *string
}
func foo() (*user, error) {
  var myname string
  var myemail string
  // some code here to fetch myname and myemail
  u := user{}
  u.name = &myname
  u.email = &myemail
  return &u, nil
}

我知道返回指向局部变量的指针是安全的，因为局部变量将在函数的范围内继续存在，因此我不担心从函数 foo() 返回 &u。

我关心的是作业：

u.name = &myname
  u.email = &myemail

go编译器在堆中分配 u.name 和 u.email 是否只是偶然，以便我能够在函数外部访问它，或者有一些保证它总是有效（通过指针转义分析机制）？

如果上面的代码不安全，我会回退到如下所示的代码：

u.name = new(string)
  *u.name = myname
  ...

解决方案

我进一步深入挖掘，并从 here 和 here 中找出如何进一步调查这一点并满足我的查询，即在结构中设置指向局部变量的指针确实是安全的，该结构本身作为函数的指针返回。

我的程序（打印行号以便更好地理解）：

1 package main
  2
  3 import "fmt"
  4
  5 type user struct {
  6   name *string
  7 }
  8
  9 func setname() (*user) {
 10   myname := "soumya"
 11   u := user{}
 12   u.name = &myname
 13   return &u
 14 }
 15
 16 func main() {
 17   v := setname()
 18   fmt.println(*v.name)
 19 }

go run -gcflags='-m -m' 的输出：

$ go run -gcflags='-m -m' main.go
./main.go:9:6: can inline setName as: func() *user { myname := "soumya"; u := user literal; u.Name = &myname; return &u }
./main.go:16:6: cannot inline main: function too complex: cost 93 exceeds budget 80
./main.go:17:15: inlining call to setName func() *user { myname := "soumya"; u := user literal; u.Name = &myname; return &u }
./main.go:18:14: inlining call to fmt.Println func(...interface {}) (int, error) { return fmt.Fprintln(io.Writer(os.Stdout), fmt.a...) }
./main.go:13:10: &u escapes to heap
./main.go:13:10:        from ~r0 (return) at ./main.go:13:3
./main.go:11:3: moved to heap: u
./main.go:12:12: &myname escapes to heap
./main.go:12:12:        from u (dot-equals) at ./main.go:12:10
./main.go:12:12:        from &u (address-of) at ./main.go:13:10
./main.go:12:12:        from ~r0 (return) at ./main.go:13:3
./main.go:10:3: moved to heap: myname
./main.go:18:15: *v.Name escapes to heap
./main.go:18:15:        from ~arg0 (assign-pair) at ./main.go:18:14
./main.go:18:14: io.Writer(os.Stdout) escapes to heap
./main.go:18:14:        from io.Writer(os.Stdout) (passed to call[argument escapes]) at ./main.go:18:14
./main.go:17:15: main &myname does not escape
./main.go:17:15: main &u does not escape
./main.go:18:14: main []interface {} literal does not escape
:1: os.(*File).close .this does not escape
soumya

输出表明 &myname 在第 1 行转义到堆。 12，因此是安全的。 此外，在第 1 行之后它不再转义。 17.

今天关于《将指向局部变量的指针分配给在 Golang 中作为指针返回的结构是否安全》的内容就介绍到这里了，是不是学起来一目了然！想要了解更多关于的内容请关注golang学习网公众号！