[golang learning notes] is parameter transfer in go language value transfer or reference transfer

Preface

Go All parameters in are passed Value passed , It is a copy of data . Specifically, it is divided into reference type and non reference type

• Non reference type （ Value type ）：int,string,float,bool, Array and struct;

  characteristic ： After value type variable declaration , What is stored directly is the corresponding data .

• Reference type ： The pointer ,slice,map,channel, Interface , Functions, etc .

  characteristic ： The variable stores a memory address value , The space pointed to by this address value is the final value . Memory is usually allocated in the heap , When no task variable references this address , The data space corresponding to the address becomes garbage , adopt GC Recycling .

Here I'm talking about value passing , It means that the reference type is passed , In fact, it is the actual address of the value , That is, a copy of the address stored in the current variable is transferred .

Value passed

Code ：

package main

import "fmt"

func main() {
    
   var value = 3

   // because int Value type   So you need to get the address character 
   fmt.Printf("modify before addr: %p value: %d\n", &value, value)

   modify(value)

   // Print again 
   fmt.Printf("modify after main addr: %p value: %d\n", &value, value)
}

func modify(value int) {
    

   value = 0

   fmt.Printf("modify addr: %p value: %d\n", &value, value)
}

Output ：

modify before addr: 0xc000018080 value: 3
modify addr: 0xc000018088 value: 0
modify after main addr: 0xc000018080 value: 3

It can be found that the two addresses are not the same address , And the arguments will not be modified

reference

At this time, we use slice Give an example

Code ：

package main

import "fmt"

func main() {
    

   value := []int{
    1, 2, 3}
   fmt.Printf("modify begin addr: %p value: %d\n", value, value)
   fmt.Printf("modify begin addr: %p value: %d\n", &value, value)

   modify1(value)

   fmt.Printf("modify after addr: %p value: %d\n", value, value)
   fmt.Printf("modify after addr: %p value: %d\n", &value, value)
}

func modify1(value []int) {
    
   value[0] = 0
   fmt.Printf("modify addr: %p value: %d\n", value, value)
   fmt.Printf("modify addr: %p value: %d\n", &value, value)
}

result ：

modify begin addr: 0xc0000b4000 value: [1 2 3]
modify begin addr: 0xc0000a4018 value: [1 2 3]
modify addr: 0xc0000b4000 value: [0 2 3]
modify addr: 0xc0000a4078 value: [0 2 3]
modify after addr: 0xc0000b4000 value: [0 2 3]
modify after addr: 0xc0000a4018 value: [0 2 3]

You can find

This address is the same whether it is an argument or an internal address of a function , The other address is different .

This is because slice is a reference type , Then the address of the actual data is stored in this variable , When passing parameters , What we send is the saved address , Instead of saving this address . That is to say, we passed this address value , Then a memory is opened inside the function to store this address , Then we can see whether it is outside or inside , The address value passed is unchanged . The address where this address is saved is changed . That's why golang Is the reason for value transmission .

So modify the data in the function , In fact, it is to modify the data in the saved address , So it will affect the outside of the function .