What is the difference between pointer passing and value passing in golang?

Go allows parameters to be passed by pointers (sometimes called references) and values. In this article, we will compare the two approaches, paying particular attention to the different contexts that may influence the choice.

Pointer passing and value passing

Strictly speaking, there is only one passing method for go methods or functions, then It's just passing by value. Each time a variable is passed as an argument, a new copy of the variable is created and passed to the function or method being called. The copies are allocated at different memory addresses.

In the case of passing a variable by pointer, a new copy will be created pointing to the same memory address. To get a feel for the difference, let's see how it works.

Value passing

package main

import "fmt"

type Person struct {  
    firstName string
    lastName  string
}

func changeName(p Person) {  
    p.firstName = "Bob"
}

func main() {  
    person := Person {
        firstName: "Alice",
        lastName: "Dow",
    }

    changeName(person)

    fmt.Println(person)
}

Running the code will get the following output:

{Alice Dow}

Please note that even though the function changeName changes firstName to "Bob", The change will not affect the variable person in the main function. This happens because the function changeName modifies a copy of the variable person, not person itself.

Pointer passing

package main
import "fmt"
type Person struct {  
    firstName string
    lastName  string
}
func changeName(p *Person) {  
    p.firstName = "Bob"
}
func main() {  
    person := Person {
        firstName: "Alice",
        lastName: "Dow",
    }
    changeName(&person)
    fmt.Println(person)
}

Running the code will get the following output:

{Bob Dow}

In this case, the variable person in function main is in the function changeName was modified. This happens because &person and p are two different pointers to the same structure stored at the same memory address.

Variables cannot be modified

We have no other choice but to pass by value. So this variable cannot be modified downstream. Vice versa, if a variable is expected to be modified, it must be passed through a pointer.

The variable is a large structure

If the variable is a large structure and performance is an issue, it is best to pass the variable through a pointer. This avoids copying the entire structure in memory.

The variable is a map or slice

Map and slice in Go are reference types and should be passed by value.

Passing by value is usually less expensive

Even though Go looks a bit like C, its compiler works differently. C's analogy doesn't always work with Go. Passing by value may be less expensive than passing by pointer in Go. This happens because Go uses escape analysis to determine whether the variable can be safely allocated on the function's stack frame, which may be much less expensive than allocating the variable on the heap. Passing by value simplifies escape analysis in Go and provides better assignment opportunities for variables.

Summary

The difference between pointer passing and value passing

1. Pointer passing It is an address, not the data in the address. It transfers less data and is more efficient than value transfer. In general, pointers can be used instead of value transfers.

2. When the pointer is passed, the modification of the space data pointed to by the pointer in the calling function will affect the caller. Because they point to the same area, the pointer transfer will not affect the caller's data.

Related recommendations: golang tutorial

The above is the detailed content of What is the difference between pointer passing and value passing in golang?. For more information, please follow other related articles on the PHP Chinese website!