Go 中slice, map, chan, strcuct 是值传递么？

Slice 也是值传递么？

看个例子吧:

func TestSliceReference(t *testing.T)  {
 var args =  []int64{1,2,3}
 fmt.Printf("切片args的地址： %p\n",args)
 modifiedNumber3(args)
 fmt.Println(args)
}

func modifiedNumber3(args []int64)  {
 fmt.Printf("形参切片的地址 %p \n",args)
 args[0] = 10
}

运行结果：

=== RUN   TestSliceReference
切片args的地址： 0xc000016120
形参切片的地址 0xc000016120 
[10 2 3]
--- PASS: TestSliceReference (0.00s)
PASS

发现没有，切片的地址和形参的地址为啥一样， 难道也问题？不是值传递？上面可以看到，我们并没有用取址符 & 来进行地址转换，就把 slice 打印出来来，再测试一下:

func TestSliceReference2(t *testing.T)  {
 var args =  []int64{1,2,3}
 fmt.Printf("切片args的地址： %p \n",args)
 fmt.Printf("切片args第一个元素的地址： %p \n",&args[0])
 fmt.Printf("直接对切片args取地址%v \n",&args)
 modifiedNumber4(args)
 fmt.Println(args)
}

func modifiedNumber4(args []int64)  {
 fmt.Printf("形参切片的地址 %p \n",args)
 fmt.Printf("形参切片args第一个元素的地址： %p \n",&args[0])
 fmt.Printf("直接对形参切片args取地址%v \n",&args)
 args[0] = 10
}

运行结果

=== RUN   TestSliceReference2
切片args的地址： 0xc0000ee030 
切片args第一个元素的地址： 0xc0000ee030 
直接对切片args取地址&[1 2 3] 
形参切片的地址 0xc0000ee030 
形参切片args第一个元素的地址： 0xc0000ee030 
直接对形参切片args取地址&[1 2 3] 
[10 2 3]
--- PASS: TestSliceReference2 (0.00s)
PASS

可以看到的是 使用 & 地址符进行取址是无效的，而且使用 %p 取出的地址是和第一个元素地址是一样的。为啥这样？看 fmt.Printf 源码

fmt包,print.go中的printValue这个方法,截取重点部分，因为`slice`也是引用类型，所以会进入这个`case`：
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)
    return
   }
  }
  fallthrough
 case reflect.Chan, reflect.Func, reflect.UnsafePointer:
  p.fmtPointer(f, verb)

可以看到 p.buf.writeByte('&') 这个代码打印地址输出结果带有 & , 这个就是为啥

fmt.Printf("切片args的地址： %p \n",args)

打印出来的是一个地址 0xc0000ee030。

为啥打印出来的切片中还会包含 "[]" 呢?

看下 printValue 源码：

case reflect.Array, reflect.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(']')
  }

因为递归调用了 p.printValue(a, verb, depth+1) 进行打印， 这个就是为啥

fmt.Printf("直接对切片args取地址%v \n",&args)

输出直接对切片args取地址

&[1 2 3]

还有个问题， 为啥 %p 输出的内存地址 和 slice 结构里面第一个元素的地址是一样的呢？

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
 }
...... 省略部分代码
// If v's Kind is Slice, the returned pointer is to the first
// element of the slice. If the slice is nil the returned value
// is 0.  If the slice is empty but non-nil the return value is non-zero.
 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 {
 ....... 省略部分代码

上面有一句话，If v’s Kind is Slice, the returned pointer is to the first。意思是对于 slice 类型，返回的是元素第一个元素的地址，这里正好解释上面为什么 fmt.Printf("切片args的地址：%p \n",args)和fmt.Printf("形参切片的地址 %p \n",args)打印出来的地址是一样的，因为args是引用类型，所以他们都返回slice这个结构里的第一个元素的地址。

Slice 的结构

//runtime/slice.go
type slice struct {
 array unsafe.Pointer
 len   int
 cap   int
}

slice 是一个结构体， 第一个元素是指针类型，这个指针指向的是底层数组的第一个指针。所以当 slice 类型的时候， fmt.Printlnf() d打印的是第一个元素的地址。其实也是指针处理，只不过指针的存放的内容是第一个元素的内存地址，但是这个指针的在传递过程中是会拷贝的。

slice 其实也是值传递，为啥引用类型传递可以修改原内容的数据， 因为底层默认传递的指向第一个元素地址的指针。容易混淆的是 fmt.printf() 打印的是第一个这个传递指针对应的内容，而不是存储指针的地址，会给人一种错觉，以为是引用传递。

map 是值传递么？

map 没有明显的指针

func TestMapReference(t *testing.T)  {
 persons:=make(map[string]int)
 persons["asong"]=8

 addr:=&persons

 fmt.Printf("原始map的内存地址是：%p\n",addr)
 modifiedAge(persons)
 fmt.Println("map值被修改了，新值为:",persons)
}

func modifiedAge(person map[string]int)  {
 fmt.Printf("函数里接收到map的内存地址是：%p\n",&person)
 person["asong"]=9
}

运行结果：

=== RUN   TestMapReference
原始map的内存地址是：0xc00000e038
函数里接收到map的内存地址是：0xc00000e040
map值被修改了，新值为: map[asong:9]
--- PASS: TestMapReference (0.00s)
PASS

接着看一下 map 源码

//src/runtime/map.go
// 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 {
 mem, overflow := math.MulUintptr(uintptr(hint), t.bucket.size)
 if overflow || mem > maxAlloc {
  hint = 0
 }

 // initialize Hmap
 if h == nil {
  h = new(hmap)
 }
 h.hash0 = fastrand()

map 使用 make 函数返回的是一个 hmap 类型的指针，func modifiedAge(persons map[string]int) 其实和 func modifiedAge(person *hmap) 意思是一样的，这样实际上传递也是使用了指针的副本进行传递， 属于值传递， map 也是引用类型，但是传递的类型不是引用，也是值传递，传递的是指针的拷贝。

chan 是值传递么

func TestChanReferencr(t *testing.T) {
 p := make(chan bool)
 fmt.Printf("原始chan的内存地址是：%p\n", &p)
 go func(p chan bool) {
  fmt.Printf("函数里接收到chan的内存地址是：%p\n", &p)
  //模拟耗时
  time.Sleep(2 * time.Second)
  p <- true
 }(p)

 select {
 case l := <-p:
  fmt.Println(l)
 }
}

运行结果

=== RUN   TestChanReferencr
原始chan的内存地址是：0xc000120028
函数里接收到chan的内存地址是：0xc000120030
true
--- PASS: TestChanReferencr (2.00s)
PASS

看到实参和形参地址返回的是不一样的，chan 的底层实现

// src/runtime/chan.go
func makechan(t *chantype, size int) *hchan {
 elem := t.elem

 // compiler checks this but be safe.
 if elem.size >= 1<<16 {
  throw("makechan: invalid channel element type")
 }
 if hchanSize%maxAlign != 0 || elem.align > maxAlign {
  throw("makechan: bad alignment")
 }

 mem, overflow := math.MulUintptr(elem.size, uintptr(size))
 if overflow || mem > maxAlloc-hchanSize || size < 0 {
  panic(plainError("makechan: size out of range"))
 }

其实可以看到 和 map 有点类型，通过 mak 函数，返回的也是一个 hchan 类型的指针，实际上在操作中，传递的是指针的副本。属于值传递。

struct 是值传递么？

看个例子

type Persons struct {
 Name string
 Age  int64
}

func TestStructRerence(t *testing.T) {
 per := Persons{
  Name: "asong",
  Age:  int64(8),
 }
 fmt.Printf("原始struct地址是：%p\n", &per)
 modifiedAge2(per)
 fmt.Println(per)
}

func modifiedAge2(per Persons) {
 fmt.Printf("函数里接收到struct的内存地址是：%p\n", &per)
 per.Age = 10
}

运行结果：

=== RUN   TestStructRerence
原始struct地址是：0xc00000c048
函数里接收到struct的内存地址是：0xc00000c060
{asong 8}
--- PASS: TestStructRerence (0.00s)
PASS

可以看到 struct 就是值传递， 没有指针发现没？当你修改指为10 的时候，发现没有修改成功，原来 struct 中 Age 值，还是 8

总结

Go 语言中的参数传递都是值传递，虽然 Go 语言中都是值传递，但我们还是可以修改原参数中的内容的，因此传递的参数是引用类型。

https://mp.weixin.qq.com/s/4txB9cRrXE15M_9vAGXi-Q