Go 参数传递是传值还是传引用
什么是传值(值传递)?
传值的意思是:函数传递的总是原来这个东西的一个副本、一个副拷贝。比如我们传递一个 int 类型的参数,传递
的其实这个参数的一个副本;传递一个指针类型的参数,其实传递的是这个指针的一份拷贝,而不是这个指针指向的
值
对于 int 这类基础类型的我们可以很容易理解,它们就是一个拷贝,但是指针呢?我们可以通过它修改原来的值,怎
么会是一个拷贝呢?看如下示例:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 | package main import "fmt" func modify(ip *int) { fmt.Printf( "函数里接收指针的内存地址是:%p\n" ,&ip) *ip = 1 } func main() { i := 10 ip := &i fmt.Printf( "原始指针的内存地址是:%p\n" ,&ip) modify(ip) fmt.Println( "int 值被修改了,新值是:" ,i) } |
输出结果如下:
1 2 3 | 原始指针的内存地址是:0xc00007e018 函数里接收指针的内存地址是:0xc00007e028 int 值被修改了,新值是: 1 |
我们都知道,任何存放在内存里的东西都有自己的地址,指针也不例外,它虽然指向别的数据,但是也有存放该指
针的内存
首先,我们声明了一个变量 i,值为 10,它的内存存放地址是 0xc000056080,通过这个地址我们可以找到变量 i,
这个内存地址也就是变量 i 的指针 ip,指针 ip 是一个指针类型的变量,它也需要内存存放它,它的内存地址是 0xc0000
7e018,在我们传递指针变量 ip 给 modify 函数的时候,是对这个指针变量的一个拷贝,所以新拷贝的指针变量 ip 它的内
存地址就变了,是新的 0xc00007e028,不管是 0xc00007e018 还是 xc00007e028 我们都可以称之为指针的指针,他们
指向同一个指针 0xc000056080,这个 0xc000056080 又指向 变量 i,这也就是为什么我们可以修改变量 i 的值
什么是引用传递?
在 Go 语言中没有引用传递,以上面的例子为例,如果在 modify 函数里面打印的地址不变,那么就是引用传递
迷惑 Map
了解清楚了值传递和引用传递,但是对于 Map 类型来说,可能觉得还是迷惑,一个是我们可以通过方法修改它的内容,
二个是它没有明显的指针,如下示例:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 | package main import "fmt" func modify(p map [string]int) { fmt.Printf( "函数里接收到的map内存地址:%p\n" ,&p) p[ "张三" ] = 25 } func main() { // 声明一个 map persons := make( map [string]int) persons[ "张三" ] = 19 mp := &persons fmt.Printf( "原始map的内存地址是:%p\n" ,mp) modify(persons) fmt.Println( "map值被修改了,新值是:" ,persons) } |
运行打印输出结果:
1 2 3 | 原始 map 的内存地址是:0xc000006028 函数里接收到的 map 内存地址:0xc000006038 map 值被修改了,新值是: map [张三:25] |
两个内存地址不一样,说明是值传递,那么为什么是值传递我们还可以修改 Map 的内容呢?我们先看一个
自己实现的 struct ,如下示例:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 | package main import "fmt" // 声明一个结构体 type Person struct { Name string } func modify(p Person) { fmt.Printf( "函数里接收到的Person内存地址:%p\n" ,&p) p.Name = "李四" } func main() { p := Person{ "张三" } fmt.Printf( "原始Person的内存地址是:%p\n" ,&p) modify(p) fmt.Println(p) } |
运行打印输出:
1 2 3 | 原始Person的内存地址是:0xc00004a1c0 函数里接收到的Person内存地址:0xc00004a1d0 {张三} |
我们看到,自己定义的 Person 类型,在传递参数的时候也是值传递,但是它的值并没有被修改,这也就
是说 map 类型 和我们自己定义 struct 类型是不一样的,我们把 modify 函数接收的参数改为 Person 的指针:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 | package main import "fmt" // 声明一个结构体 type Person struct { Name string } func modify(p *Person) { fmt.Printf( "函数里接收到的Person内存地址:%p\n" ,&p) p.Name = "李四" } func main() { p := Person{ "张三" } fmt.Printf( "原始Person的内存地址是:%p\n" ,&p) modify(&p) fmt.Println(p) } |
运行打印结果:
1 2 3 | 原始Person的内存地址是:0xc00004a1c0 函数里接收到的Person内存地址:0xc00007e020 {李四} |
看上面的输出结果,我们发现这次被修改了,那么指针类型的可以被修改,非指针类型的不能被修改,是不是我们
使用 make 创建的 map 就是一个指针类型呢?,看一下 Go 源码:
源码地址:https://github.com/golang/go/blob/master/src/runtime/map.go
1 2 3 | func makemap64(t *maptype, hint int64, h *hmap) *hmap { // 省略无关代码 } |
我们看到 make 函数返回的是一个 hmap 类型的指针 *hmap,也就是 map == *hmap。现在再来看 func modify(p Person)
其实就是 func modify(p *Persoon) ,所以,这里 Go 通过 make 函数,为我们省去了指针的操作,在这里 map 可以理解为引用
类型但不是传引用
Slice 类型
slice 类型也是引用类型,它也可以在函数中修改对应的内容:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 | package main import "fmt" func modify(ages []int) { fmt.Printf( "函数里接收到 slice 的内存地址:%p\n" ,ages) ages[0] = 6 } func main() { ages := []int{10,20,30} fmt.Printf( "原始 slice 的内存地址:%p\n" ,ages) modify(ages) fmt.Println(ages) } |
运行打印结果,发现的确是被修改了,而且在这里我们打印 slice 内存地址可以直接通过 %p,不用使用
& 取地址符转换,我们看一下 fmt.Printf 源码:
1 2 3 4 5 6 7 8 9 10 11 | func (p *pp) fmtPointer(value reflect.Value, verb rune) { var u uintptr switch value.Kind() { case reflect.Chan, reflect.Func, reflect.Map, reflect.Ptr, reflect.Slice, reflect.UnsafePointer: u = value.Pointer() default : p.badVerb(verb) return } // 省略部分代码 } |
通过上面的源码发现,对于 map、slice 等被当成指针处理,通过 value.Pointer() 获取对应值的指针:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 | func (v Value) Pointer() uintptr { // TODO: deprecate k := v.kind() switch k { case Chan, Map, Ptr, UnsafePointer: return uintptr(v.pointer()) case Func: if v.flag&flagMethod != 0 { // As the doc comment says, the returned pointer is an // underlying code pointer but not necessarily enough to // identify a single function uniquely. All method expressions // created via reflect have the same underlying code pointer, // so their Pointers are equal. The function used here must // match the one used in makeMethodValue. f := methodValueCall return **(**uintptr)(unsafe.Pointer(&f)) } p := v.pointer() // Non-nil func value points at data block. // First word of data block is actual code. if p != nil { p = *(*unsafe.Pointer)(p) } return uintptr(p) case Slice: return (*SliceHeader)(v.ptr).Data } panic(&ValueError{ "reflect.Value.Pointer" , v.kind()}) } |
看上面的代码,如果类型是 slice 的话返回的是 slice 这个结构体里,字段 Data 第一个元素的地址:
1 2 3 4 5 6 7 8 9 10 11 | type SliceHeader struct { Data uintptr Len int Cap int } type slice struct { array unsafe.Pointer len int cap int } |
所以,我们通过 %p 打印的 slice 变量 ages 的地址其实就是内部存储数组元素的地址,slice 是一种结构体 +
元素指针的混合类型
Go 语言中所有的传参都是值传递,都是一个副本、一个拷贝。因为拷贝的内容是非引用类型(int、string、struct等这些),这样就在函数
中无法修改原内容数据的;有的是引用类型(map、slice等),这样的就可以修改原内容数据
是否可以修改原内容数据,和传值、传引用没有必然的关系,在 Go 语言中,虽然只有传值,但是我们也可以修改原内容数据,因为参数
是引用类型,引用类型和传引用是两个概念
Go 只有值传递
【推荐】编程新体验,更懂你的AI,立即体验豆包MarsCode编程助手
【推荐】博客园携手 AI 驱动开发工具商 Chat2DB 推出联合终身会员
【推荐】抖音旗下AI助手豆包,你的智能百科全书,全免费不限次数
【推荐】轻量又高性能的 SSH 工具 IShell:AI 加持,快人一步