首先，我们得区分数组和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]}
