How Does Pointer Dereferencing Work in Go, and Why Are the Results Sometimes Unexpected?

Exploring Pointer Dereferencing in Go

In the Go programming language, pointers play a crucial role in manipulating data, particularly when working with structs. The ability to dereference pointers provides a powerful way to access and modify data indirectly. In this discussion, we explore the mechanics of pointer dereferencing in Go, unraveling the surprises that may arise.

The Surprise in Pointer Dereferencing

Consider the following Go code snippet:

package main

import "fmt"

type Vertex struct {
    X, Y int
}

func main() {
    p := Vertex{1, 2}  // has type Vertex
    q := &p // has type *Vertex
    t := *q
    q.X = 4
    u := *q
    fmt.Println(p, q, t, u, t == u)
}

Upon execution, this code produces the output:

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

The unexpected result is that t retains the original value of q, even though q.X was modified. This behavior stems from the nature of pointer dereferencing in Go.

Unveiling the Truth: Pointer Dereferencing

When accessing a value through a pointer, Go dereferences the pointer, essentially providing a temporary copy of the value being pointed to. In our example, when we dereference q to create t, we obtain a copy of the Vertex struct. As a result, any changes made to q will not be reflected in t.

To observe changes in q through t, we need to maintain the pointer relationship. The following modified code illustrates this:

package main

import "fmt"

type Vertex struct {
    X, Y int
}

func main() {
    p := Vertex{1, 2}  // has type Vertex
    q := &p // has type *Vertex
    t := q
    q.X = 4
    u := *q
    fmt.Println(p, q, t, u, *t == u)
}

This time, the output reflects the expected behavior:

{1 2} &{4 2} &{4 2} {4 2} true

By preserving the pointer relationship between q and t, we ensured that modifications made to q would be propagated to t.

Parallels in C and C

It is important to note that the pointer dereferencing behavior in Go is consistent with that in languages like C and C .

struct Vertex {
    int x;
    int y;
};

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

Running this C code produces output identical to Go's, reinforcing that pointer dereferencing behavior follows similar principles across these languages.

In conclusion, while pointer dereferencing in Go may initially seem surprising, it operates in a logical and consistent manner. By understanding that dereferencing creates temporary copies, programmers can harness pointers effectively to navigate and manipulate data structures with precision.

The above is the detailed content of How Does Pointer Dereferencing Work in Go, and Why Are the Results Sometimes Unexpected?. For more information, please follow other related articles on the PHP Chinese website!