Golang函数内slice进行append时不改变外部值问题

Golang函数内slice进行append时不影响外部值问题

这个标题…在看完这篇文章之后应该就能知道，这么说是不正确的，虽然看起来好像是这样的，哈哈哈哈

问题引入：下面这样一段代码会输出什么？

package main

import "fmt"

func main() {
	arr := make([]int, 3, 4)
	arr[0] = 0
	arr[1] = 1
	arr[2] = 2
	fmt.Printf("main before: len: %d cap:%d data:%+v\n", len(arr), cap(arr), arr)
	ap1(arr)
	fmt.Printf("main ap1 after: len: %d cap:%d data:%+v\n\n", len(arr), cap(arr), arr)
}
func ap1(arr []int) {
	fmt.Printf("ap1 before:  len: %d cap:%d data:%+v\n", len(arr), cap(arr), arr)
	arr[0] = 11
	arr = append(arr, 111)
	fmt.Printf("ap1 after:  len: %d cap:%d data:%+v\n", len(arr), cap(arr), arr)
}

输出：

main before: len: 3 cap:4 data:[0 1 2]
ap1 before:  len: 3 cap:4 data:[0 1 2]
ap1 after:  len: 4 cap:4 data:[11 1 2 111]
main ap1 after: len: 3 cap:4 data:[11 1 2]

可以发现，函数内append之后，外部实参切片的值真的没改变，但到底是没改变，还是 “看不到” 呢？
在Golang参数传递：值传递那篇文章中有说过，slice是值传递，但是slice本身是一个结构体，包含一个指针，指向底层数组，将slice按值传递给函数，在函数内对其修改，影响将会传递到函数外，因为底层的数组被修改了。

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

可以打印一下地址值看看：

func main() {
	arr := make([]int, 3, 4)
	arr[0] = 0
	arr[1] = 1
	arr[2] = 2
	fmt.Printf("main before: len: %d cap:%d data:%+v, slice addr:%p, arr[0] addr:%p\n", len(arr), cap(arr), arr, &arr, &arr[0])
	ap1(arr)
	fmt.Printf("main ap1 after: len: %d cap:%d data:%+v\n\n", len(arr), cap(arr), arr)
}
func ap1(arr []int) {
	fmt.Printf("ap1 before: len: %d cap:%d data:%+v, slice addr:%p, arr[0] addr:%p\n", len(arr), cap(arr), arr, &arr, &arr[0])
	arr[0] = 11
	arr = append(arr, 111)
	fmt.Printf("ap1 after: len: %d cap:%d data:%+v, slice addr:%p, arr[0] addr:%p\n", len(arr), cap(arr), arr, &arr, &arr[0])
}

输出：

既然都是指向的同一个数组，为什么实参slice输出的内容有些被修改了，有些没被修改呢？一切还要从slice的len这个属性说起，就算cap再大，它也只能感知到len范围内的内容，之外的感知不到的…画图说明如下：

ok，接下来再做几个实验：

func main() {
	arr := make([]int, 3, 4)
	arr[0] = 0
	arr[1] = 1
	arr[2] = 2
	fmt.Printf("main before: len: %d cap:%d data:%+v, slice addr:%p, arr[0] addr:%p\n", len(arr), cap(arr), arr, &arr, &arr[0])
	ap2(arr)
	fmt.Printf("main ap2 after: len: %d cap:%d data:%+v\n\n", len(arr), cap(arr), arr)
	ap3(arr)
	fmt.Printf("main ap3 after: len: %d cap:%d data:%+v\n\n", len(arr), cap(arr), arr)
	ap4(arr)
	fmt.Printf("main ap4 after: len: %d cap:%d data:%+v\n", len(arr), cap(arr), arr)
}
func ap2(arr []int) {
	fmt.Printf("ap2 before:  len: %d cap:%d data:%+v\n", len(arr), cap(arr), arr)
	arr = append(arr, 222)
	arr[0] = 22
	fmt.Printf("ap2 after:  len: %d cap:%d data:%+v\n", len(arr), cap(arr), arr)
}
func ap3(arr []int) {
	fmt.Printf("ap3 before: len: %d cap:%d data:%+v, slice addr:%p, arr[0] addr:%p\n", len(arr), cap(arr), arr, &arr, &arr[0])
	arr = append(arr, 333,333)
	arr[0] = 33
	fmt.Printf("ap3 after: len: %d cap:%d data:%+v, slice addr:%p, arr[0] addr:%p\n", len(arr), cap(arr), arr, &arr, &arr[0])
}
func ap4(arr []int) {
	fmt.Printf("ap4 before: len: %d cap:%d data:%+v, slice addr:%p, arr[0] addr:%p\n", len(arr), cap(arr), arr, &arr, &arr[0])
	arr[0] = 44
	arr = append(arr, 444,444)
	fmt.Printf("ap4 after: len: %d cap:%d data:%+v, slice addr:%p, arr[0] addr:%p\n", len(arr), cap(arr), arr, &arr, &arr[0])
}

输出：

为什么ap3中，向切片中append了两个元素之后，再修改其内容就影响不到实参原切片的内容了呢？

这是因为切片底层的扩容机制，当对切片进行append()操作，若是元素数量超过原有切片的容量，将会使得切片扩容，这就是问题所在。扩容后的切片，本质上是产生一个新的底层数组，并把旧数组的值复制进去，然后旧数组被回收掉。如果在函数内对切片添加元素导致扩容，会导致元素内的切片指向一个新的数组，但是函数外的切片仍然指向原来旧的数组，则将会导致影响无法传递到函数外。如果希望函数内对切片扩容作用于函数外，就需要以指针形式传递切片。

源码：src/runtime/slice.go 中的 growslice 函数中的核心部分。

// src/runtime/slice.go
func growslice(et *_type, old slice, cap int) slice {
	// ...省略部分
	newcap := old.cap
	doublecap := newcap + newcap
	if cap > doublecap {
		newcap = cap
	} else {
		if old.len < 1024 {
			newcap = doublecap
		} else {
			// Check 0 < newcap to detect overflow
			// and prevent an infinite loop.
			for 0 < newcap && newcap < cap {
				newcap += newcap / 4
			}
			// Set newcap to the requested cap when
			// the newcap calculation overflowed.
			if newcap <= 0 {
				newcap = cap
			}
		}
	}
	// ...省略部分
}

指针形式传递切片：【注意切片指针类型寻址的时候要(*指针)[index]，因为**[]优先级比较高**】

func main() {
	arr := make([]int, 3, 4)
	arr[0] = 0
	arr[1] = 1
	arr[2] = 2
	fmt.Printf("main before: len: %d cap:%d data:%+v, slice addr:%p, arr[0] addr:%p\n", len(arr), cap(arr), arr, &arr, &arr[0])
	ap5(&arr)
	fmt.Printf("main ap5 after: len: %d cap:%d data:%+v, slice addr:%p, arr[0] addr:%p\n", len(arr), cap(arr), arr, &arr, &arr[0])
}
func ap5(arr *[]int) {
	fmt.Printf("ap5 before: len: %d cap:%d data:%+v, pointer addr:%p, arr[0] addr:%p\n", len(*arr), cap(*arr), *arr, &(arr), &(*arr)[0])
	*arr = append(*arr, 555,555)
	(*arr)[0] = 55
	fmt.Printf("ap5 after: len: %d cap:%d data:%+v, pointer addr:%p, arr[0] addr:%p\n", len(*arr), cap(*arr), *arr, &(*arr), &(*arr)[0])
}

可以看到，在函数内部对slice扩容之后，形参和实参的底层数组都换到了同一个地址

再做个小实验，前面说slice只能感知到len范围内的内容，之外的感知不到，那要是把之外的换到之内呢？答案是肯定的

func main() {
	arr := make([]int, 3, 4)
	arr[0] = 0
	arr[1] = 1
	arr[2] = 2
	fmt.Printf("main before: len: %d cap:%d data:%+v, slice addr:%p, arr[0] addr:%p\n", len(arr), cap(arr), arr, &arr, &arr[0])
	reverse1(arr)
	fmt.Printf("main reverse1 after: len: %d cap:%d data:%+v\n", len(arr), cap(arr), arr)
	reverse2(arr)
	fmt.Printf("main reverse2 after: len: %d cap:%d data:%+v\n", len(arr), cap(arr), arr)
}
func reverse1(arr []int) {
	fmt.Printf("reverse1 before:  len: %d cap:%d data:%+v\n", len(arr), cap(arr), arr)
	arr = append(arr, 111)
	for i, j := 0, len(arr) - 1; i < j; i++ {
		j = len(arr) - (i + 1)
		arr[i], arr[j] = arr[j], arr[i]
	}
	fmt.Printf("reverse1 after:  len: %d cap:%d data:%+v\n", len(arr), cap(arr), arr)
}
func reverse2(arr []int) {
	fmt.Printf("reverse2 before:  len: %d cap:%d data:%+v\n", len(arr), cap(arr), arr)
	arr = append(arr, 222,22)
	for i, j := 0, len(arr) - 1; i < j; i++ {
		j = len(arr) - (i + 1)
		arr[i], arr[j] = arr[j], arr[i]
	}
	fmt.Printf("reverse2 after:  len: %d cap:%d data:%+v\n", len(arr), cap(arr), arr)
}

再来看点切片的其他知识吧，切片可以用上面实验中用的make的方式生成，也可以从数组中切，那切的话又有什么问题呢？

func main() {
	s := make([]int, 2, 10)
	fmt.Printf("s: %v, s[1] addr: %p\n", s, &s[1])
	b := s[1:3:4] //b的内容对应s的坐标范围：[1,3),len=3-1=2，cap=4-1=3
	fmt.Printf("b: %v, b[0] addr: %p\n", b, &b[0])

	c := append(b, 2)
	fmt.Println("after c := append(b,2):")
	fmt.Println("s:", s)
	fmt.Println("b:", b)
	fmt.Printf("c: %v, len: %v, cap:%v, c[0] addr: %p\n", c, len(c), cap(c), &c[0])

	fmt.Println("由于切片d长度为4，超出b的容量，go会给切片d分配新内存，以后对s的操作都与d无关")
	d := append(b, 4, 5)
	fmt.Println("after d := append(b,4,5):")
	fmt.Println("s:", s)
	fmt.Println("b:", b)
	fmt.Println("c:", c)
	fmt.Printf("d: %v, len: %v, cap:%v, d[0] addr:%p\n", d, len(d), cap(d), &d[0])
	s = append(s, 3, 3)
	fmt.Println("after s = append(s,3,3):")
	fmt.Println("s:", s)
	fmt.Println("b:", b)
	fmt.Println("c:", c)
	fmt.Println("d:", d)

	b = append(b, 6)
	fmt.Println("after b = append(b, 6):")
	fmt.Println("s:", s)
	fmt.Println("b:", b)
	fmt.Println("c:", c)
	fmt.Println("d:", d)
	fmt.Println("由于切片b长度变为4，超出b的容量，go会给切片b分配新内存，以后对b的操作都与基于b的切片无关")
	b = append(b, 7)
	fmt.Println("after b = append(b, 7):")
	fmt.Println("s:", s)
	fmt.Printf("b: %v, b[0] addr: %p\n", b, &b[0])
	fmt.Println("c:", c)
	fmt.Println("d:", d)
	b[0] = 8
	fmt.Println("after b[0] = 8:")
	fmt.Println("s:", s)
	fmt.Println("b:", b)
	fmt.Println("c:", c)
	fmt.Println("d:", d)
}

ps：关于copy函数：

copy()将切片s的内容复制给切片s1：返回复制的元素数
若元素不够，则只拷贝一部分；
s和s1数据空间相互独立，相互不影响

s := []int{1,2}
s1 := make([]int,len(s)*2,cap(s)*3)

copy(s1,s)
fmt.Println(len(s),cap(s),s)
fmt.Println(len(s1),cap(s1),s1)
//执行结果：
2 2 [1 2]
4 6 [1 2 0 0]

参考