引用类型:映射(map),数组切片(slice),通道(channel),方法与函数。
非引用类型:整型,字符串,布尔,数组
我们知道在内存中的任何东西都有自己的内存地址,普通值,指针都有自己的内存地址
i := 10
ip := &i
i的内存地址为: 0xc042060080,i的指针的内存地址为 0xc042080018
比如 我们创建一个整型变量 i,该变量的值为10,有一个指向整型变量 i 的指针ip,该ip包含了 i 的内存地址 0xc042060080 。但是ip也有自己的内存地址 0xc042080018。
那么在Go语言传递参数时,我们可能会有以下两种假设:
①函数参数传递都是值传递,也就是传递原值的一个副本。无论是对于整型,字符串,布尔,数组等非引用类型,还是映射(map),数组切片(slice),通道(channel),方法与函数等引用类型,前者是传递该值的副本的内存地址,后者是传递该值的指针的副本的内存地址。
②函数传递时,既包含整型,字符串,布尔,数组等非引用类型的值传递,传递该值的副本,也包括映射(map),数组切片(slice),通道(channel),方法与函数等引用类型的引用传递,传递该值的指针。
现在我们根据上述两种假设来探讨一下。
首先我们知道对于非引用类型:整型,字符串,布尔,数组在当作参数传递时,是传递副本的内存地址,也就是值传递
func main() {
i := 10 //整形变量 i
ip := &i //指向整型变量 i 的指针ip,包含了 i 的内存地址
fmt.Printf("main中i的值为:%v,i 的内存地址为:%v,i的指针的内存地址为:%v\n",i,ip,&ip)
modifyBypointer(i)
fmt.Printf("main中i的值为:%v,i 的内存地址为:%v,i的指针的内存地址为:%v\n",i,ip,&ip)
}
func modify(i int) {
fmt.Printf("modify i 为:%v,i的指针的内存地址为:%v\n",i,&i)
i = 11
}
----output----
main中 i 的值为:10,i 的内存地址为:0xc0420080b8,i 的指针的内存地址为:0xc042004028
modify i 为:10,i 的指针的内存地址为:0xc0420080d8
main中 i 的值为:10,i 的内存地址为:0xc0420080b8,i 的指针的内存地址为:0xc042004028
上面在函数接收的参数中没有使用指针,所以在传递参数时,传递的是该值的副本,内存地址会改变,因此在函数中对该变量进行操作不会影响到原变量的值。
内存分布图如下:
如果我将上面函数的参数传递方式改一下,改为接收参数的指针
func main() {
i := 10 //整形变量 i
ip := &i //指向整型变量 i 的指针ip,包含了 i 的内存地址
fmt.Printf("main中i的值为:%v,i 的内存地址为:%v,i的指针的内存地址为:%v\n",i,ip,&ip)
modifyBypointer(ip)
fmt.Printf("main中i的值为:%v,i 的内存地址为:%v,i的指针的内存地址为:%v\n",i,ip,&ip)
}
func modifyBypointer(i *int) {
fmt.Printf("modifyBypointer i 的内存地址为:%v,i的指针的内存地址为:%v\n",i,&i)
*i = 11
}
---output---
main中i的值为:10,i 的内存地址为:0xc042060080,i的指针ip的内存地址为:0xc042080018
modifyBypointer i 的内存地址为:0xc042060080,i的指针ip的内存地址为:0xc042080028
main中i的值为:11,i 的内存地址为:0xc042060080,i的指针ip的内存地址为:0xc042080018
将函数的参数改为传递指针后,函数内部对变量的修改就会影响到原变量的值,且不会影响到原变量的内存地址。但是可以看出main中各个参数的内存地址与函数中接收到的内存地址不一致,也就是说指针作为函数参数的传递过程中,是传递了该指针的副本地址,不是原指针地址。
那么既然函数中的指针地址与main中的指针地址不一致,那么我们在函数中对变量进行修改时,函数中对变量的修改又怎么会影响到main中原变量的值呢?
这是因为,虽然函数中的指针地址与main中的指针地址不一致,但是它们都指向同一个整形变量的内存地址,所以无论哪一方对变量i进行操作都会影响到变量i,且另一方是可以观察到的。
我们来看一下这个内存分布图
到目前为止,我们验证了非引用类型和指针的参数传递都是传递副本,那么对于引用类型的参数传递又是如何的呢?
①映射map
我们使用make初始化一个映射map时,实际上返回的是该映射map的一个指针,具体源码如下
// makemap implements Go map creation for make(map[k]v, hint).
// If the compiler has determined that the map or the first bucket
// can be created on the stack, h and/or bucket may be non-nil.
// If h != nil, the map can be created directly in h.
// If h.buckets != nil, bucket pointed to can be used as the first bucket.
func makemap(t *maptype, hint int, h *hmap) *hmap {}
也就是说,对于引用类型map来讲,实际上在作为传递参数时还是使用了指针的副本进行传递,属于值传递。
②chan类型
使用make初始化 chan类型,底层其实跟map一样,都是返回该值的指针
func makechan(t *chantype, size int) *hchan {}
③Slice类型
Slice类型对于之前的map,chan类型不太一样,比如下面这个代码示例
func main() {
i := []int{1,2,3}
fmt.Printf("i:%p\n",i)
fmt.Println("i[0]:",&i[0])
fmt.Printf("i:%v\n",&i)
}
---output---
i:0xc04205e0c0
i[0]: 0xc04205e0c0
i:&[1 2 3]
我们可以看到,使用&操作符表示slice的地址是无效的,而且使用%p输出的内存地址与slice的第一个元素的地址是一样的,那么为什么会出现这样的情况呢?
我们来看一下在 fmt/print.go中的printValue函数源码
case reflect.Ptr:
// pointer to array or slice or struct? ok at top level
// but not embedded (avoid loops)
if depth == 0 && f.Pointer() != 0 {
switch a := f.Elem(); a.Kind() {
case reflect.Array, reflect.Slice, reflect.Struct, reflect.Map:
p.buf.WriteByte('&') //这就是使用 &打印地址输出结果前面带有“&”的原因
p.printValue(a, verb, depth+1) //然后递归获取vaule的内容
return
}
}
如果是slice或者数组就用[]包围
} else {
p.buf.WriteByte('[')
for i := 0; i < f.Len(); i++ {
if i > 0 {
p.buf.WriteByte(' ')
}
p.printValue(f.Index(i), verb, depth+1)
}
p.buf.WriteByte(']')
}
以上就是为什么使用 fmt.Printf(“i:%v\n”,&i) 会输出 i:&[1 2 3]的原因。
然后我们再来分析一下为什么使用%p输出的内存地址与slice的第一个元素的地址是一样的。
继续看fmt/print.go中的 fmtPointer 源码
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
}
通过源代码发现,对于chan、map、slice,Func等被当成指针处理,通过value.Pointer获取对应的值的指针。
value.Pointer的源码如下:
// 如果v的类型是Func,则返回的指针是底层代码指针,但不一定足以唯一地标识单个函数。
// 唯一的保证是当且仅当v是nil func值时结果为零。
//
//如果v的类型是Slice,则返回的指针指向切片的第一个元素。
//如果切片为nil,则返回值为0。如果切片为空但非nil,则返回值为非零。
func (v Value) Pointer() uintptr {
k := v.kind()
switch k {
case Chan, Map, Ptr, UnsafePointer:
return uintptr(v.pointer())
case Func:
if v.flag&flagMethod != 0 {
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类型的时候,fmt.Printf返回是slice这个结构体里第一个元素的地址。说到底,又转变成了指针处理,只不过这个指针是slice中第一个元素的内存地址。之前说Slice类型对于之前的map,chan类型不太一样,不一样就在于slice是一种结构体+第一个元素指针的混合类型,通过元素array(Data)的指针,可以达到修改slice里存储元素的目的。
type slice struct {
array unsafe.Pointer //这里的指针其实是第一个元素的指针
len int
cap int
}
根据slice与map,chan对比,我们可以总结一条规律:
可以通过某个变量类型本身的指针(如map,chan)或者该变量类型内部的元素的指针(如slice的第一个元素的指针)修改该变量类型的值。
因此slice也跟chan与map一样,属于值传递,传递的是第一个元素的指针的副本。
总结:在Go语言中只存在值传递(要么是该值的副本,要么是指针的副本),不存在引用传递。之所以对于引用类型的传递可以修改原内容数据,是因为在底层默认使用该引用类型的指针进行传递,但是也是使用指针的副本,依旧是值传递。
思考问题:
①既然slice是使用第一个元素的内存地址作为slice的指针,那么如果出现两个相同的slice,它们的指针岂不会相同
②slice在作为参数传递时,可以修改原slice的数据,那么可以修改原slice的len和cap吗