Go 参数传递是传值还是传引用

什么是传值(值传递)？

     传值的意思是：函数传递的总是原来这个东西的一个副本、一个副拷贝。比如我们传递一个 int 类型的参数，传递

的其实这个参数的一个副本；传递一个指针类型的参数，其实传递的是这个指针的一份拷贝，而不是这个指针指向的

值

    对于 int 这类基础类型的我们可以很容易理解，它们就是一个拷贝，但是指针呢？我们可以通过它修改原来的值，怎

么会是一个拷贝呢？看如下示例：

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)
}

　　输出结果如下：

原始指针的内存地址是：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 类型来说，可能觉得还是迷惑，一个是我们可以通过方法修改它的内容，

二个是它没有明显的指针，如下示例：

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)
}

　　运行打印输出结果：

原始map的内存地址是：0xc000006028
函数里接收到的map内存地址：0xc000006038
map值被修改了,新值是： map[张三:25]

　　两个内存地址不一样，说明是值传递，那么为什么是值传递我们还可以修改 Map 的内容呢？我们先看一个

自己实现的 struct ，如下示例：

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)
}

　　运行打印输出：

原始Person的内存地址是：0xc00004a1c0
函数里接收到的Person内存地址：0xc00004a1d0
{张三}

　　我们看到，自己定义的 Person 类型，在传递参数的时候也是值传递，但是它的值并没有被修改，这也就

是说 map 类型 和我们自己定义 struct 类型是不一样的，我们把 modify 函数接收的参数改为 Person 的指针：

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)
}

　　运行打印结果：

原始Person的内存地址是：0xc00004a1c0
函数里接收到的Person内存地址：0xc00007e020
{李四}

　　看上面的输出结果，我们发现这次被修改了，那么指针类型的可以被修改，非指针类型的不能被修改，是不是我们

使用 make 创建的 map 就是一个指针类型呢？，看一下 Go 源码：

       源码地址：https://github.com/golang/go/blob/master/src/runtime/map.go

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 类型也是引用类型，它也可以在函数中修改对应的内容：

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 源码：

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() 获取对应值的指针：

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 第一个元素的地址：

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 只有值传递