本文内容纲要：

-传值还是传引用 -golang本质上都是传值方式调用 -普通类型的参数 -struct指针,map,slice类型的参数 -既然都是传值调用,为什么f3内修改了*Person,会导致外面的t3改变 -既然都是传值调用,为什么f4内修改了[]string,会导致外面的t4改变 -为什么f4内对[]stringappend之后,没有导致外面的t4改变 -既然都是传值调用,为什么f5内修改了map,会导致外面的t5改变 -为什么f5内增加了map中元素,会导致外面的t5改变,没有像t4那样,只变修改的部分,不变新增的部分 -总结

传值还是传引用

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

经过深入的尝试,终于弄明白了golang的传值的传引用,尝试过程记录如下,供大家参考!

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

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

普通类型的参数

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

funcparam_ref_test01(){ vart1=0 vart2="000" varf1=func(pint){ p+=1 } varf2=func(pstring){ p+="-changed" } fmt.Printf(">>>调用前:t1=%dt2=%s\n",t1,t2) f1(t1) f2(t2) fmt.Printf("<<<调用后:t1=%dt2=%s\n",t1,t2) }

运行的结果:

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

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

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

funcparam_ref_test02(){ typePersonstruct{ Namestring Ageint } vart3=&Person{ Name:"test", Age:10, } vart4=[]string{"a","b","c"} vart5=make(map[string]int) t5["hello"]=1 t5["world"]=2 varf3=func(p*Person){ p.Name="test-change" p.Age=20 } varf4=func(p[]string){ p[0]="aa" p=append(p,"d") } varf5=func(pmap[string]int){ p["hello"]=11 p["hello2"]=22 } fmt.Printf(">>>调用前:t3=%vt4=%vt5=%v\n",t3,t4,t5) f3(t3) f4(t4) f5(t5) fmt.Printf("<<<调用后:t3=%vt4=%vt5=%v\n",t3,t4,t5) }

运行的结果:

>>>调用前:t3=&{test10}t4=[abc]t5=map[hello:1world:2] <<<调用后:t3=&{test-change20}t4=[aabc]t5=map[hello:11hello2:22world:2]

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

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

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

funcparam_ref_test03(){ typePersonstruct{ Namestring Ageint } vart3=&Person{ Name:"test", Age:10, } varf3=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的变化了

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

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

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

golang中的slice也是指针类型,所以和上面*Person的原因一样

为什么f4内对[]stringappend之后,没有导致外面的t4改变

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

funcparam_ref_test04(){ vars=[]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那样,只变修改的部分,不变新增的部分

同样,看代码

funcparam_ref_test05(){ varm=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的值

funcparam_ref_test06(){ vart5=make(map[string]int) t5["hello"]=1 t5["world"]=2 varf5=func(pmap[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:1world:2] 修改前参数p指向的内存地址=0xc000151590 修改前参数p内存地址=0xc0000105a0 修改后参数p指向的内存地址=0xc000151650 修改后参数p内存地址=0xc0000105a0 <<<调用后:t5=map[hello:1world:2]

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

总结

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

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

本文内容总结：传值还是传引用，golang本质上都是传值方式调用，普通类型的参数，struct指针,map,slice类型的参数，既然都是传值调用,为什么f3内修改了*Person,会导致外面的t3改变，既然都是传值调用,为什么f4内修改了[]string,会导致外面的t4改变，为什么f4内对[]stringappend之后,没有导致外面的t4改变，既然都是传值调用,为什么f5内修改了map,会导致外面的t5改变，为什么f5内增加了map中元素,会导致外面的t5改变,没有像t4那样,只变修改的部分,不变新增的部分，总结，

原文链接：https://www.cnblogs.com/wang_yb/p/12126884.html