阅读 461

golang slice介绍及扩容规则

切片slice

切片是对数组的抽象,数组的长度不可改变,切片是长度可变的动态数组。在go语言中切片的使用是明显高于数组的。

定义的三种方式

1、var 切片名 []type

var s []int
复制代码

2、使用make()函数定义,make([]type,len)

var s []int = make([]int 0)
复制代码

3、指定容量make([]type, len, cap),cap为可变参数

var s []int = make([]int,3,4)
复制代码

结构

type slice struct {
    array unsafe.Pointer
    len   int  // 长度
    cap   int  // 容量
}
复制代码

容量是指底层数组的大小,长度指可以使用的大小

容量的用处是在你用 append 扩展长度时,如果新的长度小于容量,不会更换底层数组,否则,go 会新申请一个底层数组,拷贝这边的值过去,把原来的数组丢掉。也就是说,容量的用途是:在数据拷贝和内存申请的消耗与内存占用之间提供一个权衡。

// 首先声明一个长度为3,容量为4的slice
s :=make([]int,3,4)
// 记录内存地址
fmt.Printf("%p\n",s) // 0xc0000b6000
// 当插入一个元素,slice的长度变为4,所以内存地址不变
s = append(s,4)
fmt.Printf("%p\n",s) // 0xc0000b6000
// 再插入一个元素,slice的长度变为5,已经大于声明变量时限制的容量4,所以进行扩容,更换底层数组,内存地址就改变了
s = append(s,5)
fmt.Printf("%p\n",s) // 0xc0000ba000
s = append(s,6)
fmt.Printf("%p\n",s) // 0xc0000ba000
s = append(s,7)
fmt.Printf("%p\n",s) // 0xc0000ba000
s = append(s,8)
fmt.Printf("%p\n",s) // 0xc0000ba000
// 再次扩容
s = append(s,9)
fmt.Printf("%p\n",s) // 0xc0000bc000
复制代码

slice操作会影响到底层数组的改变,频繁的内存申请会占用内存,所以在声明slice时尽量预估好容量的大小。slice的扩容规则可参考下面的扩容部分。

使用注意事项

1、由于slice的底层是数组指针,所以一些slice的copy后的操作需要特别注意

s := make([]int, 3)
s = append(s,4,5,6)
fmt.Println(s)  // [0 0 0 4 5 6]
a := s
a[3] = 8
// a数据的改变会影响到s中的元素
fmt.Println(s)  // [0 0 0 8 5 6]
复制代码

2、slice可以向后扩展,但不可以向前扩展

s := make([]int, 3)
s = append(s,4,5,6)
fmt.Println(s)  // [0 0 0 4 5 6]
a := s[1:4]
fmt.Println(a) // [0 0 4]
// 虽然a中没有5 6这两个元素,但一样可以取到
fmt.Println(a[0:5])  // [0 0 4 5 6]
// 这种取值是不行的
fmt.Println(a[4])
复制代码

上面的a取了s三个元素,

扩容规则

slice的cap是在用append扩展长度时,控制底层数组的存储是否要发生改变。 下面是golang底层slice扩容时一些比较关键的代码,但并不是扩容的全部代码

newcap := old.cap
doublecap := newcap + newcap
if cap > doublecap {
        newcap = cap
} else {
        if old.cap < 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
                }
        }
}
复制代码

上面代码的意思就是

1、如果新的容量大于旧容量的2倍,则直接使用新的容量

s:=make([]int,3,4)
s = append(s,4,5,6,7,8,9)
fmt.Println(cap(s)) // 10
复制代码

上面本来运行完,cap应该为9,但实际结果为10,其实是go当元素被添加到切片时,当新容量为奇数时,容量增加1

2、如果1不满足,老的容量小于1024,则新的容量直接等于旧容量的2倍

s:=make([]int,3,3)
s = append(s,4)
fmt.Println(cap(s)) // 6
复制代码

3、如果1不满足,旧容量大于等1024,且旧容量小于需要的容量,则旧容量不停的*1.25,直到大于新的容量

s := make([]int,1024,1024)
// 旧容量1024
fmt.Println(cap(s)) // 1024
s = append(s,1)
// 扩容完 1024 * 1.25 = 1280
fmt.Println(cap(s)) // 1280
add := make([]int,255)
s = append(s,add...)
// 再添加255个元素正好达到1280,容量不变
fmt.Println(cap(s)) // 1280
// 神奇的事情发生了,再次扩容应该为1280 * 1.25 = 1600,但实际为1696
s = append(s,1) 
fmt.Println(cap(s)) // 1696
复制代码

最后一次扩容本应该为1600,但实际为1696,其实slice扩容源码里上面的代码只是比较关键的一部分,后面还有有一些操作,感兴趣的可以深入研究一下。

文章分类
后端
文章标签