7.Go 函数参数传递到底是值传递还是引用传递？

【点击观看视频】Go 函数参数传递到底是值传递还是引用传递？

先说下结论：

Go语言中所有的传参都是值传递（传值），都是一个副本，一个拷贝。

参数如果是非引用类型（int、string、struct等这些），这样就在函数中就无法修改原内容数据；如果是引用类型（指针、map、slice、chan等这些），这样就可以修改原内容数据。

是否可以修改原内容数据，和传值、传引用没有必然的关系。在C++中，传引用肯定是可以修改原内容数据的，在Go语言里，虽然只有传值，但是我们也可以修改原内容数据，因为参数是引用类型

引用类型和引用传递是2个概念，切记！！！

什么是值传递？

将实参的值传递给形参，形参是实参的一份拷贝，实参和形参的内存地址不同。函数内对形参值内容的修改，是否会影响实参的值内容，取决于参数是否是引用类型

什么是引用传递？

将实参的地址传递给形参，函数内对形参值内容的修改，将会影响实参的值内容。Go语言是没有引用传递的，在C++中，函数参数的传递方式有引用传递。

下面分别针对Go的值类型（int、struct等）、引用类型（指针、slice、map、channel），验证是否是值传递，以及函数内对形参的修改是否会修改原内容数据

int类型

形参和实际参数内存地址不一样，证明是指传递；参数是值类型，所以函数内对形参的修改，不会修改原内容数据

  1. package main
  3. import "fmt"
  5. func main() {
  6.     var i int64 = 1
  7.     fmt.Printf("原始int内存地址是 %p\n", &i)
  8.     modifyInt(i) // args就是实际参数
  9.     fmt.Printf("改动后的值是: %v\n", i)
  10. }
  12. func modifyInt(i int64) { //这里定义的args就是形式参数
  13.     fmt.Printf("函数里接收到int的内存地址是：%p\n", &i)
  14.     i = 10
  15. }
  17. 原始int内存地址是 0xc0000180b8
  18. 函数里接收到int的内存地址是：0xc0000180c0
  19. 改动后的值是: 1

形参和实际参数内存地址不一样，证明是指传递，由于形参和实参是指针，指向同一个变量。函数内对指针指向变量的修改，会修改原内容数据

  1. package main
  3. import "fmt"
  5. func main() {
  6.     var args int64 = 1                  // int类型变量
  7.     p := &args                          // 指针类型变量
  8.     fmt.Printf("原始指针的内存地址是 %p\n", &p)   // 存放指针类型变量
  9.     fmt.Printf("原始指针指向变量的内存地址 %p\n", p) // 存放int变量
  10.     modifyPointer(p)                    // args就是实际参数
  11.     fmt.Printf("改动后的值是: %v\n", *p)
  12. }
  14. func modifyPointer(p *int64) { //这里定义的args就是形式参数
  15.     fmt.Printf("函数里接收到指针的内存地址是 %p \n", &p)
  16.     fmt.Printf("函数里接收到指针指向变量的内存地址 %p\n", p)
  17.     *p = 10
  18. }
  20. 原始指针的内存地址是 0xc000110018
  21. 原始指针指向变量的内存地址 0xc00010c008
  22. 函数里接收到指针的内存地址是 0xc000110028 
  23. 函数里接收到指针指向变量的内存地址 0xc00010c008
  24. 改动后的值是: 10

slice类型

形参和实际参数内存地址一样，不代表是引用类型；下面进行详细说明slice还是值传递，传递的是指针

  1. package main
  3. import "fmt"
  5. func main() {
  6.     var s = []int64{1, 2, 3}
  7.     // &操作符打印出的地址是无效的，是fmt函数作了特殊处理
  8.     fmt.Printf("直接对原始切片取地址%v \n", &s)
  9.     // 打印slice的内存地址是可以直接通过%p打印的,不用使用&取地址符转换
  10.     fmt.Printf("原始切片的内存地址： %p \n", s)
  11.     fmt.Printf("原始切片第一个元素的内存地址： %p \n", &s[0])
  12.     modifySlice(s)
  13.     fmt.Printf("改动后的值是: %v\n", s)
  14. }
  16. func modifySlice(s []int64) {
  17.     // &操作符打印出的地址是无效的，是fmt函数作了特殊处理
  18.     fmt.Printf("直接对函数里接收到切片取地址%v\n", &s)
  19.     // 打印slice的内存地址是可以直接通过%p打印的,不用使用&取地址符转换
  20.     fmt.Printf("函数里接收到切片的内存地址是 %p \n", s)
  21.     fmt.Printf("函数里接收到切片第一个元素的内存地址： %p \n", &s[0])
  22.     s[0] = 10
  23. }
  25. 直接对原始切片取地址&[1 2 3] 
  26. 原始切片的内存地址： 0xc0000b8000 
  27. 原始切片第一个元素的内存地址： 0xc0000b8000 
  28. 直接对函数里接收到切片取地址&[1 2 3]
  29. 函数里接收到切片的内存地址是 0xc0000b8000 
  30. 函数里接收到切片第一个元素的内存地址： 0xc0000b8000 
  31. 改动后的值是: [10 2 3]

slice是一个结构体，他的第一个元素是一个指针类型，这个指针指向的是底层数组的第一个元素。当参数是slice类型的时候，fmt.printf通过%p打印的slice变量的地址其实就是内部存储数组元素的地址，所以打印出来形参和实参内存地址一样。

  1. type slice struct {
  2.     array unsafe.Pointer // 指针
  3.     len   int
  4.     cap   int
  5. }

因为slice作为参数时本质是传递的指针，上面证明了指针也是值传递，所以参数为slice也是值传递，指针指向的是同一个变量，函数内对形参的修改，会修改原内容数据

单纯的从slice这个结构体看，我们可以通过modify修改存储元素的内容，但是永远修改不了len和cap，因为他们只是一个拷贝，如果要修改，那就要传递&slice作为参数才可以。

map类型

形参和实际参数内存地址不一样，证明是值传递

  1. package main
  3. import "fmt"
  5. func main() {
  6.     m := make(map[string]int)
  7.     m["age"] = 8
  9.     fmt.Printf("原始map的内存地址是：%p\n", &m)
  10.     modifyMap(m)
  11.     fmt.Printf("改动后的值是: %v\n", m)
  12. }
  14. func modifyMap(m map[string]int) {
  15.     fmt.Printf("函数里接收到map的内存地址是：%p\n", &m)
  16.     m["age"] = 9
  17. }
  19. 原始map的内存地址是：0xc00000e028
  20. 函数里接收到map的内存地址是：0xc00000e038
  21. 改动后的值是: map[age:9]

通过make函数创建的map变量本质是一个hmap类型的指针*hmap，所以函数内对形参的修改，会修改原内容数据

  1. //src/runtime/map.go
  2. func makemap(t *maptype, hint int, h *hmap) *hmap {
  3.     mem, overflow := math.MulUintptr(uintptr(hint), t.bucket.size)
  4.     if overflow || mem > maxAlloc {
  5.         hint = 0
  6.     }
  8.     // initialize Hmap
  9.     if h == nil {
  10.         h = new(hmap)
  11.     }
  12.     h.hash0 = fastrand()
  13. }

channel类型

形参和实际参数内存地址不一样，证明是值传递

  1. package main
  3. import (
  4.     "fmt"
  5.     "time"
  6. )
  8. func main() {
  9.     p := make(chan bool)
  10.     fmt.Printf("原始chan的内存地址是：%p\n", &p)
  11.     go func(p chan bool) {
  12.         fmt.Printf("函数里接收到chan的内存地址是：%p\n", &p)
  13.         //模拟耗时
  14.         time.Sleep(2 * time.Second)
  15.         p <- true
  16.     }(p)
  18.     select {
  19.     case l := <-p:
  20.         fmt.Printf("接收到的值是: %v\n", l)
  21.     }
  22. }
  24. 原始chan的内存地址是：0xc00000e028
  25. 函数里接收到chan的内存地址是：0xc00000e038
  26. 接收到的值是: true

通过make函数创建的chan变量本质是一个hchan类型的指针*hchan，所以函数内对形参的修改，会修改原内容数据

  1. // src/runtime/chan.go
  2. func makechan(t *chantype, size int) *hchan {
  3.     elem := t.elem
  5.     // compiler checks this but be safe.
  6.     if elem.size >= 1<<16 {
  7.         throw("makechan: invalid channel element type")
  8.     }
  9.     if hchanSize%maxAlign != 0 || elem.align > maxAlign {
  10.         throw("makechan: bad alignment")
  11.     }
  13.     mem, overflow := math.MulUintptr(elem.size, uintptr(size))
  14.     if overflow || mem > maxAlloc-hchanSize || size < 0 {
  15.         panic(plainError("makechan: size out of range"))
  16.     }
  17. }

struct类型

形参和实际参数内存地址不一样，证明是值传递。形参不是引用类型或者指针类型，所以函数内对形参的修改，不会修改原内容数据

  1. package main
  3. import "fmt"
  5. type Person struct {
  6.     Name string
  7.     Age  int
  8. }
  10. func main() {
  11.     per := Person{
  12.         Name: "test",
  13.         Age:  8,
  14.     }
  15.     fmt.Printf("原始struct的内存地址是：%p\n", &per)
  16.     modifyStruct(per)
  17.     fmt.Printf("改动后的值是: %v\n", per)
  18. }
  20. func modifyStruct(per Person) {
  21.     fmt.Printf("函数里接收到struct的内存地址是：%p\n", &per)
  22.     per.Age = 10
  23. }
  25. 原始struct的内存地址是：0xc0000a6018
  26. 函数里接收到struct的内存地址是：0xc0000a6030
  27. 改动后的值是: {test 8}