函数的参数传递

go语言中传入和返回参数在调用和返回时都使用值传递，需要注意的是指针、切片和map等引用型对象指向的内容在参数传递中不会发生复制，而是将指针进行复制，类似于创建一次引用。

测试参数传递：

package main

import (
	"fmt"
)

// 用于测试值传递效果的结构体
type Data struct {
	complax  []int
	instance InnerData
	ptr      *InnerData
}

type InnerData struct {
	a int
}

// 值传递测试函数
func passByValue(inFunc Data) Data {
	fmt.Printf("inFunc value: %+v\n", inFunc)
	
	fmt.Printf("inFunc ptr: %p\n", &inFunc)

	return inFunc
}

func main() {
	in := Data{
		complax: []int{1, 2, 3},
		instance: InnerData{
			5,
		},

		ptr: &InnerData{1},
	}

	fmt.Printf("in value: %+v\n", in)

	fmt.Printf("in ptr: %p\n", &in)

	out := passByValue(in)

	fmt.Printf("out value: %+v\n", out)

	fmt.Printf("out ptr: %p\n", &out)
}

输出：

in value: {complax:[1 2 3] instance:{a:5} ptr:0xc00000c198}
in ptr: 0xc000060330
inFunc value: {complax:[1 2 3] instance:{a:5} ptr:0xc00000c198}
inFunc ptr: 0xc0000603c0
out value: {complax:[1 2 3] instance:{a:5} ptr:0xc00000c198}
out ptr: 0xc000060390

从运行结果中发现：

• 所有的Data结构的指针地址都发生了变化，意味着所有的结构都是一块新的内存。无论是将Data传入函数内部，还是通过函数返回值传回Data，都会发生复制行为。
• 所有的Data中的成员值都没有发生变化，原样传递，意味着所有参数都是值传递。
• Data结构的ptr成员在传递过程中保持一致，表示指针在函数参数值传递中传递的只是指针值，不会复制指针指向的部分。

切片的传递

在go中，切片类型的变量实际上存放的是一个地址，该地址为其引用的底层数组的第一个元素的地址，也可以说是这个数组的地址。

如图所示，创建一个名为s的切片：

var s = []int{1,2,3}

变量s储存在栈区，地址为0x000050420，其值并不是数组[1, 2, 3]，而是数组[1, 2, 3]的地址。该数组存放在堆区，地址为0x000074080（第一个元素的地址，后面开辟了连续的地址空间存放后续元素）。

因此，将切片传入函数中，形参是实参值的拷贝，此时虽然形参和实参本身是不同的内存空间，但他们存放的值都指向同一底层数组，因此当形参改变时（添加元素、改变某元素值等），函数调用后实参同样会被改变（其实是指向的底层数组的改变），这和其他一些类型传入函数时有很大不同。

改变元素值

package main

import (
	"fmt"
)

func change(a []int) {
	a[0] = 2
	fmt.Printf("%v, %p\n", a, a)
}

func main() {
	s := make([]int, 5)
	fmt.Printf("%v, %p\n", s, s)

	change(s)

	fmt.Printf("%v, %p\n", s, s)
}

输出：

[0 0 0 0 0], 0xc00000e390
[2 0 0 0 0], 0xc00000e390
[2 0 0 0 0], 0xc00000e390

形参a和实参s都指向了相同的数组，通过形参a改变数组元素值，实参同样会受到影响。

增加元素

package main

import (
	"fmt"
)

func change(a []int) {
	a = append(a, 3)
	fmt.Printf("%v, %p\n", a, a)
}

func main() {
	s := make([]int, 5)
	fmt.Printf("%v, %p\n", s, s)

	change(s)

	fmt.Printf("%v, %p\n", s, s)
}

输出：

[0 0 0 0 0], 0xc00007c060
[0 0 0 0 0 3], 0xc00006a0f0
[0 0 0 0 0], 0xc00007c060

这时发现实参指向的数组并没有变化。而形参添加元素后指向的地址变了，其指向的数组是原数组的拷贝，因此不会影响原数组。

当添加元素时，如果数组容量不够，则将原数组进行扩容，扩容后由于要求数组的地址空间连续，因此原地址不满足条件，会再开辟一片新的空内存区域存放扩容后的数组，因此形参存放的地址改变了，而实参对应的原数组并没有改变。

那么根据这个原理，如果数组容量够的话，增加元素后数组地址不会改变，因此形参的改变理应也会影响实参。如下所示，在s初始化时增加其容量：

package main

import (
	"fmt"
)

func change(a []int) {
	a = append(a, 3)
	fmt.Printf("%v, %p\n", a, a)
}

func main() {
	s := make([]int, 5, 8)
	fmt.Printf("%v, %p\n", s, s)

	change(s)

	fmt.Printf("%v, %p\n", s, s)
}

输出：

[0 0 0 0 0], 0xc000014280
[0 0 0 0 0 3], 0xc000014280
[0 0 0 0 0], 0xc000014280

如同预测的一样，形参和实参指向的地址是一样的，但为什么和实参的输出不一样呢？

s的输出应该和a是一样的，只不过s初始化时预定义的长度为5，当数组长度变为6之后，s并不能查看到数组后面的元素，需要重新进行切片（实际上是把s的右指针向后移动，增加s的长度），这样就能看到变化了：

package main

import (
	"fmt"
)

func change(a []int) {
	a = append(a, 3)
	fmt.Printf("%v, %p\n", a, a)
}

func main() {
	s := make([]int, 5, 8)
	fmt.Printf("%v, %v, %p\n", s, s[:6], s)

	change(s)

	fmt.Printf("%v, %v, %p\n", s, s[:6], s)
}

输出：

[0 0 0 0 0], [0 0 0 0 0 0], 0xc000014280
[0 0 0 0 0 3], 0xc000014280
[0 0 0 0 0], [0 0 0 0 0 3], 0xc000014280

参考

go语言关于切片类型内存地址的理解