传递结构和结构的指针有什么区别,它们不是两个指针吗？

Question

例如

var myStructRef *Vertex
var myStruct Vertex
myStructRef = &Vertex{2, 3}
myStruct = Vertex{2, 3}

fmt.Println(myStructRef)
fmt.Println(myStruct)
changeByReferenceStruct(myStructRef)
changeByValueStruct(myStruct)
fmt.Println(myStructRef)
fmt.Println(myStruct)

和

func changeByValueStruct(myStruct Vertex) {
    myStruct.X = 5
    fmt.Println(myStruct)
}


func changeByReferenceStruct(myStruct *Vertex) {
    myStruct.X = 7
    fmt.Println(myStruct)
}

是不是myStructRef *Vertex和myStruct Vertex指向结构本身的指针？为什么在修改函数中的结构时行为存在差异？

golang在changeByValueStruct解析参数时是否会创建一个新结构？

Answer 1

在Go中传递参数只有一种方法,那就是按值.这意味着总是在传递参数时,会创建值的副本并将其传递给函数.

当您将指针作为参数传递时,底层发生的事情是创建该指针的副本并将其传递给基础函数.它不应该与传递引用相混淆.

让我们看一个更好地掌握它的例子:

package main

import (
    "fmt"
)

type Point struct {
    x int
    y int
}

func (p Point) String() string {
    return fmt.Sprintf("(%d, %d)", p.x, p.y)
}

func modifyValue(point Point) {
    point.x += 10
}

func modifyPointer(point *Point) {
    point.x = 5
    point.y = 5
}

func modifyReference(point *Point) {
    point = &Point{5, 5}
}

func main() {
    p := Point{0, 0}
    fmt.Println(p) // prints (0, 0)

    modifyValue(p)
    fmt.Println(p) // prints (0, 0)

    modifyPointer(&p)
    fmt.Println(p) // prints (5, 5)

    p = Point{0, 0}
    modifyReference(&p)
    fmt.Println(p) // prints (0, 0)
}

modifyValue函数内部发生的是修改了一个完全不同的Point结构实例,因此调用该函数时传递的值不受影响.

在第二个示例中,传递了指向结构的指针,因此可以从外部可见的方式修改结构的字段.

最有趣的一点是由最后一个函数modifyReference完成的.如果您熟悉其他语言中提供的引用范例,您可能希望能够完全修改引用的对象,但这不会发生.这是因为你正在修改作为参数传递的指针的副本.

您可能想知道,如果所有内容都是按值传递的,那么何时应该传递指针以及何时传递值.传递值可确保调用者函数传递的结构不会发生任何更改,因此当您需要此行为时,请转到该值.这样做的缺点是整个对象的副本,如果它太大,内存成为一个问题.

如果你将一个大结构作为参数传递,使用指针会更好,因为它可以节省空间,但是你不能保证对象不会受到任何改变.

Answer 2

将结构传递给函数参数会复制值。并且传递结构指针不会。所以传递结构不能更新字段值。

package main

import (
    "fmt"
)

type Foo struct {
    value int
}

func PassStruct(foo Foo) {
    foo.value = 1
}

func PassStructPointer(foo *Foo) {
    foo.value = 1
}

func main() {
    var foo Foo

    fmt.Printf("before PassStruct: %v\n", foo.value)
    PassStruct(foo)
    fmt.Printf("after PassStruct: %v\n", foo.value)

    fmt.Printf("before PassStructPointer: %v\n", foo.value)
    PassStructPointer(&foo)
    fmt.Printf("after PassStructPointer: %v\n", foo.value)
}

https://play.golang.org/p/AM__JwyaJa