Go Structs: Does Dereferencing Create a Copy or a Reference?

Dereferencing Structs in Go: Unveiling Copying vs. Referencing

In Go, dereferencing a struct using the * operator may seem to return a new copy of the struct instead of the original address. This can lead to misunderstandings.

Consider the following code:

type me struct {
    color string
    total int
}

In this code, we define a struct named me.

Within the study function, we create a me struct p and initialize its color field. We then return the address of p using &p.

func study() *me {
    p := me{}
    p.color = "tomato"
    return &p
}

In the main function, we get the address of p.color and store it in &p.color. We then dereference p and store the result in obj.

func main() {
    p := study()
    obj := *p
}

Now, let's examine the output:

&p.color = 0x10434120
&obj.color = 0x10434140   //different than &p.color!

When we compare &p.color and &obj.color, we find that they have different addresses. This might suggest that when we dereference p, we create a new copy of the struct.

However, this is not the case. When we use *p, we are copying the value of the struct pointed to by p. It's equivalent to using:

var obj me = *p

obj is a new variable of type me, initialized to the value of *p. This causes obj to have a separate memory address.

It's important to note that obj is of type me, while p is of type *me. They are distinct values. Changing the obj fields will not affect the fields within p.

If we want to modify the original struct, we can use:

obj := p
// equivalent to: var obj *me = p

In this case, obj points to the same object as p. They have different addresses but hold the same address within the actual me object.

The above is the detailed content of Go Structs: Does Dereferencing Create a Copy or a Reference?. For more information, please follow other related articles on the PHP Chinese website!