如果 n 为 0 呢？

m := make([]int, 0)
n := make([]int, 0)
t := make([]int, 0)
fmt.Printf("%pn", m) // 0x5ae008
fmt.Printf("%pn", n) // 0x5ae008
fmt.Printf("%pn", t) // 0x5ae008

golang在底层为长度等于0的数组指向了同一个地址。

cc := [0]int{}
fmt.Printf("%pn", &cc) // 0x5ae008

append一定会导致切片扩容吗？

关于扩容，当底层数组长度不够了，会创建一个新的数组，将原数据拷贝过来，同时切片的pointer为新数组的首地址，每次会扩容多少呢，按照既定的策略来，每个版本可能不一样。

既然有策略存在，那肯定不是每次添加数据都会取扩容的。

那么，以下程序会触发扩容吗？

s1 := make([]int, 0)

fmt.Printf("%pn", s1) // 0x5ae008

s1 = append(s1, 1)
fmt.Println(len(s1)) // 1
fmt.Println(cap(s1)) // 1
fmt.Printf("%pn", s1) // 0xc00000a0f8

s1 = append(s1, 10, 11)
fmt.Println(len(s1)) // 3
fmt.Println(cap(s1)) // 4
fmt.Printf("%pn", s1) // 0xc000014440

s1 = append(s1, 6)
fmt.Println(len(s1)) // 4
fmt.Println(cap(s1)) // 4
fmt.Printf("%pn", s1) // 0xc000014440 没有发生扩容

如何理解切片的容量cap？
切片是构建在数组之上的，切片的pointer指向数组中的某一个元素的地址，直到数组的尾部，这个区间就是切片的容量，也是切片的作用区间。

切片的长度，表示切片已经存储了几个元素，可以通过下标来访问。

切片的容量的意义就在于，执行append操作时如果超出了容量，系统需要对数组进行扩容，此时就会将切片的内容复制到新的数组上。

a := make([]int, 0)
a = append(a, 1,2,3,4,5,6)

fmt.Printf("%pn", a) // 0xc000012330
fmt.Println(len(a)) // 6
fmt.Println(cap(a)) // 6

b := a[:0]
fmt.Printf("%pn", b) // 0xc000012330
fmt.Println(len(b)) // 0
fmt.Println(cap(b)) // 6

c := a[2:4]
fmt.Printf("%pn", c) // 0xc000012340 地址在a的后面
fmt.Println(len(c)) // 2
fmt.Println(cap(c)) // 4

切片为引用传递。
指向同一个底层数组的多个切片会相互影响的，具体影响的范围取决于各个切片的作用区间。

a := []int{1,2,3,4,5,6,7,8}
fmt.Printf("%pn", a) // 0xc00000c540
fmt.Println("------------------------------------")
a1 := a[:3] // [1 2 3]
fmt.Printf("%pn", a1) // 0xc00000c540
fmt.Println(len(a1)) // 3
fmt.Println(cap(a1)) // 8
fmt.Println("------------------------------------")
a2 := a[:5] // [1 2 3 4 5]
fmt.Printf("%pn", a2) // 0xc00000c540
fmt.Println(len(a2)) // 5
fmt.Println(cap(a2)) // 8
fmt.Println("------------------------------------")
a3 := a[4:] // [5 6 7 8]
fmt.Printf("%pn", a3) // 0xc00000c560
fmt.Println(len(a3)) // 4
fmt.Println(cap(a3)) // 4
fmt.Println("------------------------------------")
a1[0] = 10
fmt.Println(a) // [10 2 3 4 5 6 7 8]
fmt.Println(a1) // [10 2 3]
fmt.Println(a2) // [10 2 3 4 5]
fmt.Println(a3) // [5 6 7 8]
fmt.Println("------------------------------------")
a1 = append(a1, 11)
fmt.Println(a) // [10 2 3 11 5 6 7 8]
fmt.Println(a1) // [10 2 3 11]
fmt.Println(a2) // [10 2 3 11 5]
fmt.Println(a3) // [5 6 7 8]
fmt.Println("------------------------------------")
a3 = append(a3, 12) // 已经扩容到新的数组
fmt.Println(a) // [10 2 3 11 5 6 7 8]
fmt.Println(a1) // [10 2 3 11]
fmt.Println(a2) // [10 2 3 11 5]
fmt.Println(a3) // [5 6 7 8 12]

如何做到复制切片，但不需要引用。

func copy(dst, src []Type) int

dst 必须是一个初始化了的，且长度大于0的切片，dst和src的类型要一致, copy并不会自动扩容。

a := []int{1,2,3,4,5,6,7,8}
fmt.Printf("%pn", a) // 0xc00000c4c0

var b []int
copy(b, a)
fmt.Printf("%pn", b) // 0x0
fmt.Println(b) // []

c := make([]int, 0)
copy(c, a)
fmt.Printf("%pn", c) // 0x5ac008
fmt.Println(c) // []

d := make([]int, len(a))
copy(d, a)
fmt.Printf("%pn", d) // 0xc00000c500
fmt.Println(d) // [1 2 3 4 5 6 7 8]

e := make([]int, 4)
copy(e, a)
fmt.Printf("%pn", e) // 0xc000014480
fmt.Println(e) // [1 2 3 4]

copy的使用场景：
有时候一个小的切片来自于一个大的切片的一部分(b := a[m:n])，因此它们指向同一个大的底层数组，虽然在此之后大的切片已不再使用，但是底层数组依然不会被释放，因为小的切片还在指向它，所以此时应该使用copy来产生小的切片(copy(b, a))，这样可以减少内存占用。