What's the Difference Between `&` and `*` Pointers in Go, and When Should I Use Each?

Exploring the Usage and Distinction of & and * Pointers

When working with Go functions, encountering errors related to passing variables as arguments is fairly common. Employing pointers, denoted by either & or *, can often resolve these issues. However, understanding their differences and appropriate usage is crucial.

Definition and Usage

The & operator returns the memory address of a variable, while * is used to dereference a pointer. In your example, you defined u as type User but not as a pointer to a User. Consequently, you needed to use &u because the Decode function in the json package expects an address or pointer.

If u was initially created as a pointer using u := new(User) or var u *User, the & in the call to Decode would become unnecessary.

Analogy and Example

Think of pointers as variables that store addresses. Similar to how we find our home by its address, pointers help retrieve the data stored at specific memory locations.

Suppose you have a variable x representing an address in memory. When you type &x, you're effectively obtaining the address of x itself. However, if you type *x, you're redirecting to the memory location stored in x and retrieving the actual data there.

For instance, if you have a variable y that holds the value 10 and you create a pointer to it, pointerToY, pointerToY will store the address of y.

Now, &y would give you the address of y, while &pointerToY would provide the address of the pointer itself.

Fun with Pointers

Here's a program to illustrate the concepts further:

package main

import "fmt"

func main() {
    var y int
    var pointerToY *int
    var pointerToPointerToInt **int

    y = 10
    pointerToY = &y
    pointerToPointerToInt = &pointerToY

    fmt.Println("pointerToY: ", pointerToY)
    fmt.Println("pointerToPointerToInt: ", pointerToPointerToInt)

    fmt.Println("*pointerToY: ", *pointerToY) // dereferencing to get y's value
    fmt.Println("*pointerToPointerToInt: ", *pointerToPointerToInt)

    fmt.Println("**pointerToPointerToInt: ", **pointerToPointerToInt) // dereferencing twice to get y's value
}

This program demonstrates the different outcomes when using pointers and dereferencing. It illustrates how you can access the data by redirecting through a pointer and how double dereferencing ultimately returns the original data value.

The above is the detailed content of What's the Difference Between `&` and `*` Pointers in Go, and When Should I Use Each?. For more information, please follow other related articles on the PHP Chinese website!