golang的传值调用和传引用调用

传值仍是传引用

调用函数时, 传入的参数的 传值 仍是 传引用, 几乎是每种编程语言都会关注的问题. 最近在使用 golang 的时候, 因为 传值 和 传引用 的方式没有弄清楚, 致使了 BUG.

通过深刻的尝试, 终于弄明白了 golang 的 传值 的 传引用, 尝试过程记录以下, 供你们参考!

golang 本质上都是传值方式调用

严格来讲, golang 中都是传值调用, 下面经过例子一一说明

普通类型的参数

这里的普通类型, 指的是 int, string 等原始的数据类型, 这些类型做为函数参数时, 都是 传值 调用. 这个基本没什么疑问.

func param_ref_test01() {
 var t1 = 0
 var t2 = "000"

 var f1 = func(p int) {
   p += 1
 }

 var f2 = func(p string) {
   p += "-changed"
 }

 fmt.Printf(">>>调用前: t1 = %d  t2 = %s\n", t1, t2)
 f1(t1)
 f2(t2)
 fmt.Printf("<<<调用后: t1 = %d  t2 = %s\n", t1, t2)
}

运行的结果:

>>>调用前: t1 = 0  t2 = 000
<<<调用后: t1 = 0  t2 = 000

struct 指针, map, slice 类型的参数

对于这种类型的参数, 表面上是 传引用 调用, 我也被这个表面现象迷惑过…

func param_ref_test02() {
 type Person struct {
   Name string
   Age  int
 }

 var t3 = &Person{
   Name: "test",
   Age:  10,
 }
 var t4 = []string{"a", "b", "c"}
 var t5 = make(map[string]int)
 t5["hello"] = 1
 t5["world"] = 2

 var f3 = func(p *Person) {
   p.Name = "test-change"
   p.Age = 20
 }

 var f4 = func(p []string) {
   p[0] = "aa"
   p = append(p, "d")
 }

 var f5 = func(p map[string]int) {
   p["hello"] = 11
   p["hello2"] = 22
 }

 fmt.Printf(">>>调用前: t3 = %v  t4 = %v  t5 = %v\n", t3, t4, t5)
 f3(t3)
 f4(t4)
 f5(t5)
 fmt.Printf("<<<调用后: t3 = %v  t4 = %v  t5 = %v\n", t3, t4, t5)
}

运行的结果:

>>>调用前: t3 = &{test 10}  t4 = [a b c]  t5 = map[hello:1 world:2]
<<<调用后: t3 = &{test-change 20}  t4 = [aa b c]  t5 = map[hello:11 hello2:22 world:2]

从运行结果中, 能够看出基本符合 传引用 调用的特征, 除了 t4 的 append 没有生效以外

既然都是传值调用, 为何 f3 内修改了 *Person, 会致使外面的 t3 改变

改造下 f3, 将变量的地址打印出来

func param_ref_test03() {
  type Person struct {
    Name string
    Age  int
  }

  var t3 = &Person{
    Name: "test",
    Age:  10,
  }

  var f3 = func(p *Person) {
    p.Name = "test-change"
    p.Age = 20
    fmt.Printf("参数p 指向的内存地址 = %p\n", p)
    fmt.Printf("参数p 内存地址 = %p\n", &p)
  }
  fmt.Printf("t3 指向的内存地址 = %p\n", t3)
  fmt.Printf("t3 的内存地址 = %p\n", &t3)
  f3(t3)
}

运行的结果:

t3 指向的内存地址 = 0xc00000fe20
t3 的内存地址 = 0xc000010570
参数p 指向的内存地址 = 0xc00000fe20
参数p 内存地址 = 0xc000010578

从结果能够看出, t3 和 p 都是指针类型, 可是它们的内存地址是不同的, 因此这是一个 传值 调用. 可是, 它们指向的地址(0xc00000fe20)是同样的, 因此经过 p 修改了指向的数据(*Person), t3 指向的数据也发生了变化.

只要 p 的指向地址变化, 就不会影响 t3 的变化了

var f3 = func(p *Person) {
 p = &Person{}   // 这行会改变p指向的地址
 p.Name = "test-change"
 p.Age = 20
}
f3(t3)

能够试试看, 只要加上上面代码中有注释的那行, 调用 f3 就不会改变 t3 了.

既然都是传值调用, 为何 f4 内修改了 []string, 会致使外面的 t4 改变

golang 中的 slice 也是指针类型, 因此和上面 *Person 的缘由同样

为何 f4 内对 []string append 以后, 没有致使外面的 t4 改变

代码是最好的解释, 先观察 append 以后内存地址的变化, 咱们再分析

func param_ref_test04() {
  var s = []string{"a", "b", "c"}
  fmt.Printf("s 的内存地址 = %p\n", &s)
  fmt.Printf("s 指向的内存地址 = %p\n", s)
  s[0] = "aa"
  fmt.Printf("修改s[0] 以后, s 的内存地址 = %p\n", &s)
  fmt.Printf("修改s[0] 以后, s 指向的内存地址 = %p\n", s)
  s = append(s, "d")
  fmt.Printf("append以后, s 的内存地址 = %p\n", &s)
  fmt.Printf("append以后, s 指向的内存地址 = %p\n", s)
}

运行的结果:

s 的内存地址 = 0xc00008fec0
s 指向的内存地址 = 0xc00016d530
修改s[0] 以后, s 的内存地址 = 0xc00008fec0
修改s[0] 以后, s 指向的内存地址 = 0xc00016d530
append以后, s 的内存地址 = 0xc00008fec0
append以后, s 指向的内存地址 = 0xc000096f00

首先, 不管是修改 slice 中的元素, 仍是添加 slice 的元素, 都不会改变 s 自己的地址(0xc00008fec0) 其次, 修改 slice 中的元素, 不会改变 s 指向的地址(0xc00016d530), 全部在 f4 中修改 slice 的元素, 也会改变函数 f4 外面的变量 最后, append 操做会修改 s 指向的地址, append 以后, s 和 函数 f4 外的变量已经不是指向同一地址了, 因此 append 的元素不会影响函数 f4 外的变量

既然都是传值调用, 为何 f5 内修改了 map, 会致使外面的 t5 改变

map 类型也是指针类型, 因此缘由和上面的 *Person 同样

为何 f5 内增长了 map 中元素, 会致使外面的 t5 改变, 没有像 t4 那样, 只变修改的部分, 不变新增的部分

一样, 看代码

func param_ref_test05() {
  var m = make(map[string]int)
  m["hello"] = 1
  m["world"] = 2
  fmt.Printf("m 的内存地址 = %p\n", &m)
  fmt.Printf("m 指向的内存地址 = %p\n", m)
  m["hello"] = 11
  fmt.Printf("修改m 以后, m 的内存地址 = %p\n", &m)
  fmt.Printf("修改m 以后, m 指向的内存地址 = %p\n", m)
  m["hello2"] = 22
  fmt.Printf("追加元素以后, m 的内存地址 = %p\n", &m)
  fmt.Printf("追加元素以后, m 指向的内存地址 = %p\n", m)
}

运行的结果:

m 的内存地址 = 0xc000010598
m 指向的内存地址 = 0xc000151590
修改m 以后, m 的内存地址 = 0xc000010598
修改m 以后, m 指向的内存地址 = 0xc000151590
追加元素以后, m 的内存地址 = 0xc000010598
追加元素以后, m 指向的内存地址 = 0xc000151590

根据上面的分析经验, 一目了然, 由于不管是修改仍是添加 map 中的元素, m 指向的地址(0xc000151590)都没变, 因此函数 f5 中 map 参数修改元素, 添加元素以后, 都会影响函数 f5 以外的变量.

注意 这里并非说 map 类型的参数就是 传引用 调用, 它仍然是 传值 调用, 参数 map 的地址和函数 f5 外的变量 t5 的地址是不同的 若是在函数 f5 中修改的 map 类型参数的指向地址, 就会像传值调用那样, 不影响函数 f5 外 t5 的值

func param_ref_test06() {
 var t5 = make(map[string]int)
 t5["hello"] = 1
 t5["world"] = 2

 var f5 = func(p map[string]int) {
   fmt.Printf("修改前 参数p 指向的内存地址 = %p\n", p)
   fmt.Printf("修改前 参数p 内存地址 = %p\n", &p)
   p = make(map[string]int)  // 这行改变了 p 的指向, 使得 p 和 t5 再也不指向同一个地方
   p["hello"] = 11
   p["hello2"] = 22
   fmt.Printf("修改后 参数p 指向的内存地址 = %p\n", p)
   fmt.Printf("修改后 参数p 内存地址 = %p\n", &p)
 }

 fmt.Printf("t5 指向的内存地址 = %p\n", t5)
 fmt.Printf("t5内存地址 = %p\n", &t5)
 fmt.Printf(">>>调用前: t5 = %v\n", t5)
 f5(t5)
 fmt.Printf("<<<调用后: t5 = %v\n", t5)
}

运行的结果:

t5 指向的内存地址 = 0xc000151590
t5内存地址 = 0xc000010598
>>>调用前: t5 = map[hello:1 world:2]
修改前 参数p 指向的内存地址 = 0xc000151590
修改前 参数p 内存地址 = 0xc0000105a0
修改后 参数p 指向的内存地址 = 0xc000151650
修改后 参数p 内存地址 = 0xc0000105a0
<<<调用后: t5 = map[hello:1 world:2]

虽然是 map 类型参数, 可是调用先后, t5 的值没有改变.

总结

上面的尝试不敢说有多全, 但基本能够弄清 golang 函数传参的本质.

1. 对于普通类型(int, string 等等), 就是 传值 调用, 函数内对参数的修改, 不影响外面的变量
2. 对于 struct 指针, slice 和 map 类型, 函数内对参数的修改之因此能影响外面, 是由于参数和外面的变量指向了同一块数据的地址
3. 对于 struct 指针, slice 和 map 类型, 函数的参数和外面的变量的地址是不同的, 因此本质上仍是 传值 调用
4. slice 的 append 操做会改变 slice 指针的地址, 这个很是重要!!! 我曾经写了一个基于 slice 的排序算法在这个上面吃了大亏, 调研好久才发现缘由…