Golang slice原理深度解析与面试指南

type slice struct {
	array unsafe.Pointer // 指向底层数组的指针
	len   int            // 当前长度
	cap   int            // 容量
}

s := []int{1, 2, 3}
// 内存布局：
// slice 头: {ptr: 0x1000, len: 3, cap: 3}
// 底层数组: [1, 2, 3]

func nextslicecap(newLen, oldCap int) int {
    newcap := oldCap
    doublecap := newcap + newcap
    if newLen > doublecap {
        return newLen  // 直接按需求扩容
    }
    const threshold = 256
    if oldCap < threshold {
        return doublecap  // 小切片：双倍扩容
    }
    // 大切片：1.25倍扩容，平滑过渡
    for {
        newcap += (newcap + 3*threshold) >> 2
        if uint(newcap) >= uint(newLen) {
            break
        }
    }
    return newcap
}

func modifySlice(s []int) {
	s = append(s, 4)
	fmt.Println("modifySlice:", s) // modifySlice: [1 2 3 4]
}
func main() {
	s := []int{1, 2, 3}
	modifySlice(s)
	fmt.Println("main:", s) // main: [1 2 3]
}

// 调用前
main_s = {ptr: 0x1000, len: 3, cap: 3}
// 函数调用 - 值传递
modifySlice(main_s) {
    // 创建副本
    s = {ptr: 0x1000, len: 3, cap: 3}
    // append 触发扩容
    s = append(s, 4) {
        // 分配新数组，返回新 slice 头
        return {ptr: 0x2000, len: 4, cap: 6}
    }
}
// 函数返回后
main_s = {ptr: 0x1000, len: 3, cap: 3} // 完全没变！

// 情况1：修改元素值 - 会影响（共享底层数组）
func modifyElement(s []int) {
    s[0] = 100  // 会影响原 slice
}
// 情况2：不扩容的 append - 底层数组被修改，但 len 不变
func appendNoGrowth(s []int) {
    s = append(s, 999)  // 如果 cap>len，底层数组被修改
    // 原 slice 的 len 不变，但底层数组[3] = 999
}

func main() {
    s1 := []int{1, 2, 3, 4, 5}
    s2 := s1[:3]  // [1, 2, 3]
    s2[0] = 100
    fmt.Println(s1) // 输出什么？
    
    s2 = append(s2, 999)
    fmt.Println(s1) // 输出什么？
}

func modify(s []int) {
    s = append(s, 4)
    s[0] = 999
}
func main() {
    s := []int{1, 2, 3}
    modify(s)
    fmt.Println(s)
}

var s1 []int
s2 := []int{}
s3 := make([]int, 0)
fmt.Println(s1 == nil) // true or false?
fmt.Println(s2 == nil) // true or false?
fmt.Println(len(s1), cap(s1)) // 输出什么？
fmt.Println(len(s2), cap(s2)) // 输出什么？

true
false
0 0
0 0

func main() {
    s := make([]int, 1, 1)  // len=1, cap=1
    for i := 0; i < 10; i++ {
        oldCap := cap(s)
        s = append(s, i)
        if cap(s) != oldCap {
            fmt.Printf("扩容: %d -> %d\n", oldCap, cap(s))
        }
    }
}

扩容: 1 -> 2
扩容: 2 -> 4  
扩容: 4 -> 8
扩容: 8 -> 16

func leak() []int {
    s := make([]int, 1000)
    // 使用 s...
    return s[:1] // 只返回1个元素
}
func main() {
    result := leak()
    fmt.Printf("返回的slice: len=%d, cap=%d\n", len(result), cap(result))
    // 问：这里有什么内存问题？
}

// 推荐：预先知道大致大小
s := make([]int, 0, 1000)
for i := 0; i < 1000; i++ {
    s = append(s, i)
}
// 不推荐：频繁扩容
s := []int{}
for i := 0; i < 1000; i++ {
    s = append(s, i)  // 会触发多次扩容
}

// 重用 slice 减少 GC 压力
var buffer []byte
func process() {
    buffer = buffer[:0] // 重置但不释放内存
    // 重新使用 buffer...
}

// 错误：造成内存泄漏
func getFirst(data []int) int {
    return data[0] // 整个 data 数组都无法释放
}
// 正确：只保留需要的部分
func getFirst(data []int) int {
    return data[0] // 调用者可以释放原始数据
}
// 或者显式拷贝
func getFirstCopy(data []int) int {
    copy := make([]int, 1)
    copy[0] = data[0]
    return copy[0] // 只保留一个元素
}

// 高效的数据处理
func processStream(data []byte, n int) []byte {
    return data[:n] // 零拷贝，只创建新视图
}