Go slice 剖析

首先，我们得区分数组和slice的概念

• 数组是值类型，赋值和传参会复制整个数组，⽽而不是指针
• slice 并不是数组或数组指针。它通过内部指针和相关属性引⽤用数组⽚片段，以实现变⻓长⽅方案。(通常也会称作引用类型)

• 引用类型：变量直接存放的就是一个地址值，这个地址值指向的空间存的才是值。

package main

type slice struct {
    array unsafe.Pointer
    len   int
    cap   int
}

func main() {
    **
      > array = 0xc00009e008, len = 0, cap = 1 的一个slice
      > 此时p的存储的其实是p.array, p.array存储的是底层数组的引用
      > 因为p其实是一个结构体对象，结构体对象的内存地址存储的为，首个元素的地址
    **
    
    // 1. 区分p 和 &p
    // p打印的为为底层存储结构slice结构体的首元素地址，p.array为底层数组的首元素地址。
    // &p打印出来的是slice结构体的地址
    p := make([]int, 0, 1)
    fmt.Printf("[p(引用地址)->%p],[&p(真实地址)->%p]\n", p, &p)

    // 2. 查看p的内部结构
    s := *(*slice)(unsafe.Pointer(&p))
    fmt.Printf("[&p(真实地址:%p)->%v]\n\n", &p, s)

    // 3. 直接赋值的方式
    p1 := p // 直接赋值
    fmt.Printf("[p1(引用地址)->%p],[&p1(真实地址)->%p]\n\n", p1, &p1) // 发现打印的真实地址是不一样的

    // 4. 函数传递的方式
    test1(p)
    fmt.Printf("[p(引用地址)->%p],[&p(真实地址)->%p]\n", p, &p)
    fmt.Printf("[&p(真实地址:%p)->%v],[p的值为:%v]\n", &p, *(*slice)(unsafe.Pointer(&p)), p) // 操作之后p的值
}

func test1(v []int) {
    fmt.Printf("[v(引用地址)->%p],[&v(真实地址)->%p]\n", v, &v) // 发现底层结构p没有变，但是slice地址改变了
    v = append(v, 1)
    fmt.Printf("[&v(真实地址:%p)->%v],[v的值为:%v]\n\n", &v, *(*slice)(unsafe.Pointer(&v)), v)
}

• 运行结果

[p(引用地址)->0xc000096000],[&p(真实地址)->0xc000094000]
[&p(真实地址:0xc000094000)->{0xc000096000 0 1}]

[p1(引用地址)->0xc000096000],[&p1(真实地址)->0xc00000c060]

[v(引用地址)->0xc000096000],[&v(真实地址)->0xc00000c0a0]
[&v(真实地址:0xc00000c0a0)->{0xc000096000 1 1}],[v的值为:[1]]

[p(引用地址)->0xc000096000],[&p(真实地址)->0xc000094000]
[&p(真实地址:0xc000094000)->{0xc000096000 0 1}],[p的值为:[]]

扩容方式
cap在1024之前，为newcap += newcap 【double的方式】
大于1024后，为newcap += newcap / 4 【 1/4的方式】

源码解读
.
.
. 
newcap := old.cap
    doublecap := newcap + newcap
    if cap > doublecap {
        newcap = cap
    } else {
        if old.len < 1024 {
            newcap = doublecap
        } else {
            // Check 0 < newcap to detect overflow
            // and prevent an infinite loop.
            for 0 < newcap && newcap < cap {
                newcap += newcap / 4
            }
            // Set newcap to the requested cap when
            // the newcap calculation overflowed.
            if newcap <= 0 {
                newcap = cap
            }
        }
    }
...

黑科技（了解了slice的内部结构，我们能不能手动修改len，cap呢 ？）

答案是可以的!

• 数组类型，转换切片直接使用如下 -> data[1:4:5] 这样的方式

package main

func main() {
    data := [...]int{0, 1, 2, 3, 4, 5, 6}
    s := data[1:4:5] // len = 4-1 ; cap = 5-1
    fmt.Printf("{&data[1]=%p},{s=%v}\n", &data[1], s)
    s1 := (*slice)(unsafe.Pointer(&s))
    fmt.Printf("[s(引用地址)->%p],[&s(真实地址)->%p]\n\n", s, &s)
    fmt.Printf("[&s(真实地址:%p)->%v]\n", &s, s1)
    fmt.Printf("{s=%v}\n", s)

    s1.len = 5 // 通过指针修改len为5
    fmt.Println("通过指针修改len=3，为len=5")
    //s = append(s, 10)
    fmt.Printf("[&s(真实地址:%p)->%v]\n", &s, s1)
    fmt.Printf("{s=%v}\n", s)

}

运行结果如下

{&data[1]=0xc000094008},{s=[1 2 3]}
[s(引用地址)->0xc000094008],[&s(真实地址)->0xc000096000]

[&s(真实地址:0xc000096000)->&{0xc000094008 3 4}]
{s=[1 2 3]}
通过指针修改len=3，为len=5
[&s(真实地址:0xc000096000)->&{0xc000094008 5 4}]
{s=[1 2 3 4 5]}