go特性之数组与切片的问题

wx_V9C7C

数组：
复制传递(不要按照c/c++的方式去理解，c/c++中数组是引用传递)，定长
切片：
引用传递，底层实现是3个字段 array(数组) + len（长度） +cap（容量）

1. go/src/runtime/slice.go slice结构定义：
2. type slice struct {
3.         array unsafe.Pointer
4.         len  int
5.         cap  int
6. }

复制代码

要特别注意的是，切片的引用传递指的是切片传递时，切片的array字段是引用传递的，len和cap字段依然是赋值传递。
写个伪代码：

1. type Slice struct {
2.         Array []interface{}
3.         Len int
4.         Cap int
5. }
7. func fake() {
8.         slice1 := &Slice{
9.                 Array: 指向一块连续内存的定长数组,
10.                 Len: 0,
11.                 Cap: 4
12.         }
14.         slice2 := slice1 // 这一行相当于如下：
16.         slice2 := &Slice{}
17.         slice2.Array = slice1.Array // 指向同一块内存，所以说切片是引用传递
18.         slice2.Len = slice1.Len // len字段被复制了
19.         slice2.Cap = slice2.Cap // cap字段被复制了
21.     // 后续如果触发了任一slice的array重新分配内存，另一个slice都是不知道的
22.         // 已经修改任一slice的len和cap，另一个slice也是不知道的
23. }

复制代码

最后总结题

1. //
2. //输出结果：
3. //array1: [1 2 3] array2 [100 2 3]
4. //slice1: [100 2 3] slice2 [100 2 3]
5. //
6. func TestSlice1(t *testing.T) {
7.         // 数组是赋值传递
8.         array1 := [3]int{1,2,3}
10.         // 这里array1复制了一份，array2和array1已经不是同一份数据了
11.         // 所以对数组array1，array2的修改是互不影响的
12.         array2 := array1
13.         array2[0] = 100
14.         fmt.Println("array1:", array1, "array2", array2)
16.         // 切片是引用传递
17.         slice1 := make([]int, 0)
18.         slice1 = append(slice1, 1, 2, 3)
20.         // slice2和slice1引用的同一份数据，所以slice2对已有元素的修改，会影响到slice1
21.         // 这里有个细节需要注意，往下面TestSlice2继续看
22.         slice2 := slice1
23.         slice2[0] = 100
24.         fmt.Println("slice1:", slice1, "slice2", slice2)
25. }
27. /*
28. 输出结果
29. slice1: [1 2 3] slice2 [1 2 3 4]
30. slice1: [1 2 3] slice2 [1 2 3 4 5]
31. slice1: [1 2 3] slice2 [100 2 3 4 5]
32. */
33. func TestSlice2(t *testing.T) {
34.         // 切片是引用传递
35.         slice1 := make([]int, 0, 4) // 容量是4
36.         slice1 = append(slice1, 1, 2, 3)
38.         // slice2和slice1引用的同一份数据，所以slice2对元素的修改，会影响到slice1
39.         // 特别要注意的是，这里说的引用同一份数据，实际上是指的slice1和slice2内部的ptr指向了同一个数组
40.         // 但是slice1和slice2结构中的len和cap是复制传递的
41.         slice2 := slice1
42.         // 添加第4个元素，容量足够，不会触发内部ptr数组重新分配
43.         slice2 = append(slice2, 4)
44.         fmt.Println("slice1:", slice1, "slice2", slice2)
46.         // 添加第5个元素，容量不足，slice2.ptr重新分配内存，此时slice2.ptr和slice1.ptr已经不是同一份内存了
47.         slice2 = append(slice2, 5)
48.         fmt.Println("slice1:", slice1, "slice2", slice2)
50.         // 所以这里slice2对已有元素的修改，不会影响到slice1了
51.         slice2[0] = 100
52.         fmt.Println("slice1:", slice1, "slice2", slice2)
53. }

复制代码

到此这篇关于go特性之数组与切片的问题的文章就介绍到这了,更多相关go数组切片内容请搜索咔叽论坛以前的文章或继续浏览下面的相关文章希望大家以后多多支持咔叽论坛！

原文地址：https://www.jb51.net/article/200870.htm