Go 源码深度解析之切片 Slice（数据结构/扩容机制）

type slice struct {
    array unsafe.Pointer                                 // 指向所引用的数组指针（`unsafe.Pointer` 可以表示任何可寻址的值的指针）
    len   int                                                     // 长度，当前引用切片的元素个数
    cap   int                                                      // 容量，cap 一定是大于或等于 len 的。否则会导致 panic
}

// 该函数传入需要初始化的切片的类型，长度以及容量，返回的指针会通过调用方组建成一个完成的slice结构体
func makeslice(et *_type, len, cap int) unsafe.Pointer {
   // 调用MulUintptr函数：获取创建该切片需要的内存，以及是否溢出
    mem, overflow := math.MulUintptr(et.size, uintptr(cap))
  //  如果溢出 | 超过能够分配的最大内存(2^32 - 1) | 非法输入, 报错并返回
    if overflow || mem > maxAlloc || len < 0 || len > cap {
    // 下面的注释：
   // 在创建一个长度非常大的切片时，如果超出了底层数组的容量，通常会发生“cap out of range”错误。
    // 但是go会优先返回 len 溢出的错误

        mem, overflow := math.MulUintptr(et.size, uintptr(len))
        if overflow || mem > maxAlloc || len < 0 {
      // panic 错误：len溢出
            panicmakeslicelen()
        }
     // panic 错误：容量溢出
        panicmakeslicecap()
    }
 // 调用mallocgc函数分配一块连续内存并返回该内存的首地址
    return mallocgc(mem, et, true)
}

//MulUintptr返回a*b以及乘法是否溢出。
//在受支持的平台上，这是编译器降低的内在值。
func MulUintptr(a, b uintptr) (uintptr, bool) {
    if a|b < 1<<(4*goarch.PtrSize) || a == 0 {
        return a * b, false
    }
    overflow := b > MaxUintptr/a
    return a * b, overflow
}

func slicecopy(to, fm slice, width uintptr) int {
      // 如果源切片或者目标切片有一个长度为0，那么就不需要拷贝，直接 return 
      if fm.len == 0 || to.len == 0 {
        return 0
      }
      // n 记录下源切片或者目标切片较短的那一个的长度
      n := fm.len
      if to.len < n {
        n = to.len
      }
      // 如果入参 width = 0，也不需要拷贝了，返回较短的切片的长度
      if width == 0 {
        return n
      }
      //如果开启竞争检测
      if raceenabled {
        callerpc := getcallerpc()
        pc := funcPC(slicecopy)
        racewriterangepc(to.array, uintptr(n*int(width)), callerpc, pc)
        racereadrangepc(fm.array, uintptr(n*int(width)), callerpc, pc)
      }
      if msanenabled {
        msanwrite(to.array, uintptr(n*int(width)))
        msanread(fm.array, uintptr(n*int(width)))
      }
      size := uintptr(n) * width
      if size == 1 { // common case worth about 2x to do here
        // TODO: is this still worth it with new memmove impl?
        //如果只有一个元素，那么直接进行地址转换
        *(*byte)(to.array) = *(*byte)(fm.array) // known to be a byte pointer
      } else {
        //如果不止一个元素，那么就从 fm.array 地址开始，拷贝到 to.array 地址之后，拷贝个数为size
        memmove(to.array, fm.array, size)
      }
      return n
    }

var nilSlice []int  // nil 切片：array=nil, len=0, cap=0
emptySlice := make([]int, 0)  // 空切片：array=指向空数组, len=0, cap=0

fmt.Println(nilSlice == nil)  // true
fmt.Println(emptySlice == nil)  // false
// 两者都可 append
nilSlice = append(nilSlice, 1)  // 变为 len=1, cap=1

slice := []int{1,2,3,4}
// 方式 1：重置 len=0（推荐，复用底层数组，高效）
slice = slice[:0]
// 方式 2：赋值为空切片（会创建新空切片，原数组可能被回收）
slice = []int{}
// 方式 3：nil 赋值（原数组可能被回收，后续需重新 append）
slice = nil