type slice struct {
	array unsafe.Pointer // 指向底層數(shù)組的指針
	len   int            // 當(dāng)前長度
	cap   int            // 容量
}

s := []int{1, 2, 3}
// 內(nèi)存布局：
// slice 頭: {ptr: 0x1000, len: 3, cap: 3}
// 底層數(shù)組: [1, 2, 3]

func nextslicecap(newLen, oldCap int) int {
    newcap := oldCap
    doublecap := newcap + newcap
    if newLen > doublecap {
        return newLen  // 直接按需求擴(kuò)容
    }
    const threshold = 256
    if oldCap < threshold {
        return doublecap  // 小切片：雙倍擴(kuò)容
    }
    // 大切片：1.25倍擴(kuò)容，平滑過渡
    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]
}

// 調(diào)用前
main_s = {ptr: 0x1000, len: 3, cap: 3}
// 函數(shù)調(diào)用 - 值傳遞
modifySlice(main_s) {
    // 創(chuàng)建副本
    s = {ptr: 0x1000, len: 3, cap: 3}
    // append 觸發(fā)擴(kuò)容
    s = append(s, 4) {
        // 分配新數(shù)組，返回新 slice 頭
        return {ptr: 0x2000, len: 4, cap: 6}
    }
}
// 函數(shù)返回后
main_s = {ptr: 0x1000, len: 3, cap: 3} // 完全沒變！

// 情況1：修改元素值 - 會(huì)影響（共享底層數(shù)組）
func modifyElement(s []int) {
    s[0] = 100  // 會(huì)影響原 slice
}
// 情況2：不擴(kuò)容的 append - 底層數(shù)組被修改，但 len 不變
func appendNoGrowth(s []int) {
    s = append(s, 999)  // 如果 cap>len，底層數(shù)組被修改
    // 原 slice 的 len 不變，但底層數(shù)組[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("擴(kuò)容: %d -> %d\n", oldCap, cap(s))
        }
    }
}

擴(kuò)容: 1 -> 2
擴(kuò)容: 2 -> 4  
擴(kuò)容: 4 -> 8
擴(kuò)容: 8 -> 16

func leak() []int {
    s := make([]int, 1000)
    // 使用 s...
    return s[:1] // 只返回1個(gè)元素
}
func main() {
    result := leak()
    fmt.Printf("返回的slice: len=%d, cap=%d\n", len(result), cap(result))
    // 問：這里有什么內(nèi)存問題？
}

// 推薦：預(yù)先知道大致大小
s := make([]int, 0, 1000)
for i := 0; i < 1000; i++ {
    s = append(s, i)
}
// 不推薦：頻繁擴(kuò)容
s := []int{}
for i := 0; i < 1000; i++ {
    s = append(s, i)  // 會(huì)觸發(fā)多次擴(kuò)容
}

// 重用 slice 減少 GC 壓力
var buffer []byte
func process() {
    buffer = buffer[:0] // 重置但不釋放內(nèi)存
    // 重新使用 buffer...
}

// 錯(cuò)誤：造成內(nèi)存泄漏
func getFirst(data []int) int {
    return data[0] // 整個(gè) data 數(shù)組都無法釋放
}
// 正確：只保留需要的部分
func getFirst(data []int) int {
    return data[0] // 調(diào)用者可以釋放原始數(shù)據(jù)
}
// 或者顯式拷貝
func getFirstCopy(data []int) int {
    copy := make([]int, 1)
    copy[0] = data[0]
    return copy[0] // 只保留一個(gè)元素
}

// 高效的數(shù)據(jù)處理
func processStream(data []byte, n int) []byte {
    return data[:n] // 零拷貝，只創(chuàng)建新視圖
}