切片的结构

切片是一个结构体

type slice struct {
    array unsafe.Pointer //指向底层数组
    len   int
    cap   int
}

占用内存大小: 在64bit系统上占24个字节.

//word大小
32bit: 1word=4byte
64bit: 1word=8byte

//在64bit系统上slice占24个字节
type slice struct {
    array unsafe.Pointer //8byte
    len   int            //8byte
    cap   int            //8byte
}

fmt.Println(unsafe.Sizeof([]int{})) //24

定义

字面量方式

// 字面量方式定义

var arr[]int       //nil切片: 指向nil

arr:= []int{}      //空切片,  有内存地址分配
arr:=make([]int,0)

println(a==nil,b==nil) //只能和nil比较, slice引用类型之间不支持==运算

b:= []int{1,2,5:10}

make方式

// make方式:

make([]T, len, cap)  //len参数必须, cap参数可选, 默认cap==size

len: 用于限定可读写的元素数量.
cap: 表示切片所引用数组片段的真实长度.

arr:=make([]int, 3, 5)

arr := make([]int,3)
fmt.Println(len(arr), cap(arr)) //3 3

arr := make([]int, 3, 4)
fmt.Printf("%#v",arr) //[]int{0, 0, 0}

• len和cap的说明

//len: 用于限定可读写的元素数量. 

arr := make([]int, 2, 3)
arr[0] = 0
arr[1] = 1
arr[2] = 2 // index out of range [2] with length 2

如果要扩容slice, 使用append函数. 当append时:

• 如果cap够, append使用原数组

• 如果cap不够, append会新开辟一个backend array内存空间. 并重置cap. 当cap<1000时, 成倍的增长cap; 当cap>1000,增长因子为1.25.

从数组/切片reslice

// 从数组/切片获取
    arr = [i,j,k]
    len = j-i
    cap = k-i

// 一个例子
 x:= [...]int{0,1,2,3,4,5,6,7,8,9} 
  
 操作        得到的切片                 len   cap   备注 
-------------+--------------------------+----+------+------------------------------ 
 x[:]         [0 1 2 3 4 5 6 7 8 9]     10   10   x[0:len(x)] 
 x[2:5]       [2 3 4]                   3    8
 x[2:5:7]     [2 3 4]                   3    5
 x[4:]        [4 5 6 7 8 9]             6    6    x[4:len(x)] 
 x[:4]        [0 1 2 3]                 4    10   x[0:4] 
 x[:4:6]      [0 1 2 3]                 4    6    x[0:4:6]

• 使用 arr = [i,j], 注 这里的默认cap,是原始arr的长度-i
  

• 使用arr = [i,j,k]
  

[go]slice

原文：https://www.cnblogs.com/iiiiiher/p/12178432.html