第2章_Go容器和设计思想

授课语音

Go语言切片的原理

一、切片的概述

1.1 切片是什么？

切片（slice）是 Go 语言中一个非常重要的概念，它是对数组的一种抽象，并提供了灵活的、动态的存储结构。与固定大小的数组不同，切片允许动态调整大小。

切片的核心是底层数组，它是对数组的一段连续内存区域的引用。切片可以通过修改长度（而不是重新分配数组）来支持动态扩展。

1.2 切片的组成部分

切片包含三个主要部分：

指针（Pointer）：指向底层数组的第一个元素。
长度（Length）：切片的长度，表示切片中当前元素的个数。
容量（Capacity）：切片的容量，表示从切片的起始位置到底层数组末尾的元素个数。

1.3 切片与数组的关系

切片是对数组的封装，不是数组的拷贝。
数组的大小是固定的，切片的大小可以动态变化。
当一个切片被创建时，切片的内存分配会依据其底层数组来操作。

二、切片的底层实现

2.1 切片底层结构

切片底层是通过数组来存储数据的，因此切片本质上还是通过数组来进行数据的存储与管理。一个切片类型的变量包含了三个主要元素：

type SliceHeader struct {
    Data  unsafe.Pointer // 指向底层数组的指针
    Len   int            // 切片的长度
    Cap   int            // 切片的容量
}

切片的内部结构：

Data：切片指向底层数组的指针。
Len：切片的长度，即切片当前可用的元素数量。
Cap：切片的容量，即从切片的起始位置到底层数组末尾的元素个数。

2.2 底层数组和切片的关系

切片是一个对底层数组的视图。当你创建切片时，并没有创建新的数组，而是创建了一个结构体，指向底层数组的某一部分。这意味着切片的内容是指向原始数组数据的引用。

例子：

arr := [5]int{1, 2, 3, 4, 5}
slice := arr[1:4]  // 创建一个切片，包含 arr 数组的第 2 到第 4 个元素（索引 1 到 3）

arr 是一个数组。
slice 是一个切片，它引用了 arr 数组的部分元素。

2.3 切片与底层数组的共享

切片会共享底层数组的内存空间，如果切片改变了元素的值，这些改变会反映到底层数组上。反之亦然。

arr := [5]int{1, 2, 3, 4, 5}
slice := arr[1:4]
slice[0] = 10  // 修改切片的值
fmt.Println(arr) // 输出：[1 10 3 4 5]，数组的值也改变了

三、切片的扩展与内存分配

3.1 切片的动态增长

切片的长度是可以动态增长的。通过 append() 函数，可以向切片中添加元素。当切片的容量不足时，Go 会自动为切片分配新的内存空间。

增加容量：当向切片中添加元素，且切片容量已满时，Go 会创建一个新的更大的数组，通常会将容量翻倍，并将原数组的元素复制到新数组中。

3.2 `append()` 函数的工作原理

append() 函数的工作流程如下：

如果切片容量足够，它直接向切片追加元素，更新长度。
如果切片容量不足，Go 会新分配一个更大的底层数组，并将原有数据复制到新的底层数组上，然后返回一个新的切片。

例子：

slice := []int{1, 2, 3}
slice = append(slice, 4)  // 如果切片容量不足，会自动扩展容量
fmt.Println(slice)        // 输出：[1 2 3 4]

3.3 切片的内存分配与优化

在底层，Go 会根据切片的大小和需要扩展的程度来分配内存，通常每次扩容都会将切片的容量翻倍。这种做法可以减少内存分配的次数，提高性能。

容量扩展的模式：

容量翻倍：一般情况下，当切片的容量不足时，Go 会将其容量加倍（如从 n 扩展到 2n）。
内存分配：新分配的内存空间会比原来的容量大，但不会无限制地扩展。Go 会根据运行时的条件进行合理的扩展。

四、切片的原理举例

4.1 切片的扩展与内存管理

package main

import "fmt"

func main() {
	// 创建一个初始长度为 2，容量为 2 的切片
	slice := make([]int, 2, 2)
	fmt.Println("初始切片：", slice)
	fmt.Println("初始长度：", len(slice), " 初始容量：", cap(slice))

	// 向切片中追加元素，触发切片的扩容
	slice = append(slice, 1)
	fmt.Println("扩展后切片：", slice)
	fmt.Println("扩展后长度：", len(slice), " 扩展后容量：", cap(slice))

	// 再追加元素，触发切片的再次扩容
	slice = append(slice, 2)
	fmt.Println("再次扩展后切片：", slice)
	fmt.Println("再次扩展后长度：", len(slice), " 再次扩展后容量：", cap(slice))
}

输出：

初始切片： [0 0]
初始长度： 2  初始容量： 2
扩展后切片： [0 0 1]
扩展后长度： 3  扩展后容量： 4
再次扩展后切片： [0 0 1 2]
再次扩展后长度： 4  再次扩展后容量： 4

初始切片的长度和容量是 2。
第一次扩容后，容量增加到 4，长度变为 3。
第二次扩容后，容量依然是 4，长度变为 4。

4.2 切片与底层数组的关系

package main

import "fmt"

func main() {
	// 创建一个数组
	arr := [5]int{1, 2, 3, 4, 5}
	// 创建一个切片，引用 arr 数组的一部分
	slice := arr[1:4]

	// 修改切片中的元素
	slice[0] = 10
	fmt.Println("修改后的切片:", slice)
	fmt.Println("修改后的数组:", arr)  // 原数组的值也会受到影响
}