Why Doesn't Dereferencing a Pointer in Go Modify the Original Value?

Pointer Dereferencing in Go: What's Happening?

When delving into the world of programming in Go, you may come across an intriguing behavior related to pointer dereferencing, particularly when working with structs. Consider the following example:

package main

import "fmt"

type Vertex struct {
    X, Y int
}

var (
    p = Vertex{1, 2}  // has type Vertex
    q = &Vertex{1, 2} // has type *Vertex
    r = Vertex{X: 1}  // Y:0 is implicit
    s = Vertex{}      // X:0 and Y:0
)

func main() {
    t := *q
    q.X = 4
    u := *q
    fmt.Println(p, q, r, s, t, u, t == u)
}

Running this code produces surprising results:

{1 2} &{4 2} {1 0} {0 0} {1 2} {4 2} false

You might expect t to change to {4, 2} after altering q.X, but this does not happen. What's the reason for this behavior?

Pointer Dereferencing Explained

The key to understanding this is pointer dereferencing. In Go, when you dereference a pointer (e.g., *q), you create a copy of the value it points to. So, t := *q makes a separate copy of the Vertex struct referenced by q.

Example 28's Modification Clarified:

In your modified example, when you set q.X = 4, you are only modifying the struct pointed to by q. Since t is a copy, it retains its original values.

Comparing Go and C/C

You mentioned the behavior seeming strange from a C/C perspective. However, C/C behave similarly. Consider this example:

#include <iostream>

struct Vertex
{
    int x;
    int y;
};

int main()
{
    Vertex v = Vertex{1, 2};
    Vertex* q = &v;
    Vertex t = *q;
    q->x = 4;
    std::cout << "*q: " << *q << "\n";
    std::cout << " t: " << t << "\n";
}

This C code produces the same behavior:

*q: { 4, 2 }
t: { 1, 2 }

Conclusion

In summary, when you dereference a pointer in Go, you're creating a copy of the underlying value. To observe changes made through a pointer, you must use a pointer itself, like in the modified example:

func main() {
    t := q
    q.X = 4
    u := *q
    fmt.Println(p, q, r, s, t, u, *t == u)
}

This will produce the expected output of {1 2} &{4 2} {1 0} {0 0} {4 2} {4 2} true.

The above is the detailed content of Why Doesn't Dereferencing a Pointer in Go Modify the Original Value?. For more information, please follow other related articles on the PHP Chinese website!