Go——切片困惑

分手后的思念是犯贱 2023-10-09 21:40 49阅读 0赞

### 1、数组 ###

Go的数组是有固定个相同类型元素的数据结构，底层采用连续的内存空间存放，数组一旦声明后大小就不可改变了。  
注意：Go中的数组是一种基本类型，数组的类型不仅包括其元素类型，也包括其大小，\[2\]int和\[5\]int是两个完全不同的数组类型。

##### 创建数组 #####

1.  声明时通过字面量进行初始化
2.  直接声明，不显示地进行初始化

a := [3]int{
        1, 2, 3}
    b := [...]int{
        1, 2, 3}
    c := [3]int{
        1:1, 2:3}
    var d [3]int

数组名无论作为函数实参，还是作为struct嵌入字段，或者数组之间的直接赋值，都是值拷贝，不像C语言数组名因场景不同，可能是值拷贝，也可能是指针传递：C语言数组名作为函数实参传递时，直接退化为指针，int a\[10\]、int a\[\]、int \*a在C语言中都是一个意思，就是一个指向int类型的指针；但是，当数组内嵌到C的struct里面时，又表现的是值拷贝的语义。

Go语言的数组不存在这种歧义，数组的一切传递都是值拷贝，体现在以下三个方面：

1.  数组间的直接赋值。
2.  数组作为函数参数。
3.  数组内嵌到struct中。

下面以一个示例来证明这三条：

package main
    
    import "fmt"
    
    func main() {
        
    	a := [3]int{
        1, 2, 3}
    	//直接赋值是浅拷贝
    	b := a
    
    	//修改a元素值并不影响b
    	a[2] = 4
    
    	fmt.Printf("%p,%v\n", &a, a) //0xc420016120,[1 2 4]
    	fmt.Printf("%p,%v\n", &b, b) //0xc420016140,[1 2 3]
    
    	//数组作为函数参数仍然是值拷贝
    	f(a) //0xc4200161c0,[1 2 0]
    
    	c := struct {
        
    		s [3]int
    	}{
        s: a}
    
    	//结构是值拷贝，内部的数组也是值拷贝
    	d := c
    
    	//修改c中的数组元素值并不影响a
    	c.s[2] = 20
    
    	//修改d中的数组元素值并不影响d
    	d.s[2] = 20
    
    	fmt.Printf("%p,%v\n", &a, a) //0xc420016120,[1 2 4]
    	fmt.Printf("%p,%v\n", &b, b) //0xc420016140,[1 2 3]
    	fmt.Printf("%p,%v\n", &c, c) //0xc420016200,{[1 2 20]}
    }
    
    func f(a [3]int) {
        
    	a[2] = 0
    	fmt.Printf("%p,%v\n", &a, a)
    }

### 2、切片 ###

##### 切片的创建 #####

1.  通过数组创建。  
    array\[b:e\]创建一个包括e-b个元素的切片，第一个元素是array\[b\],最后一个元素是array\[e-l\]。
2.  make。  
    通过内置的make函数创建，make(\[\]T，len,cap)中的T是切片元素类型，len是长度，cap是底层数组的容量，cap是可选参数。
3.  直接声明。  
    可以直接声明一个切片，也可以在声明切片的过程中使用字面量进行初始化，直接声明但不进行初始化的切片其值为nil。例如：

var a []int //a is nil
    var a []int []int(1,2,3,4}

##### 切片数据结构 #####

通常我们说切片是一种类似的引用类型，原因是其存放数据的数组是通过指针间接引用的。所以切片名作为函数参数和指针传递是一样的效果。切片的底层数据结构如下：  
![在这里插入图片描述][dffe1b58f5ee4e75881e627ed0284fb3.png]  
![在这里插入图片描述][5614b71a9df44f0abc344b14763698da.png]

可以看到切片的数据结构有三个成员，分别是指向底层数组的指针、切片的当前大小和底层数组的大小。当len增长超过cap时，会申请一个更大容量的底层数组，并将数据从老数组复制到新申请的数组中。

##### nil切片和空切片 #####

`make([]int,0)`与`var a []int`创建的切片是有区别的。前者的切片指针有分配，后者的内部指针为0。示例如下：

package main
    
    import (
    	"fmt"
    	"reflect"
    	"unsafe"
    )
    
    func main() {
        
    	var a []int
    	b := make([]int, 0)
    
    	if a == nil {
        
    		fmt.Println("a is nil") //a is nil
    	} else {
        
    		fmt.Println("a is not nil")
    	}
    
    	//虽然b的底层数组大小为0，但切片并不是nil
    	if b == nil {
        
    		fmt.Println("b is nil")
    	} else {
        
    		fmt.Println("b is not nil") //b is not nil
    	}
    
    	//使用反射中的SliceHeader来获取切片运行时的数据结构
    	as := (*reflect.SliceHeader)(unsafe.Pointer(&a))
    	bs := (*reflect.SliceHeader)(unsafe.Pointer(&b))
    
    	fmt.Printf("len=%d,cap=%d,type=%d\n", len(a), cap(a), as.Data) //len=0,cap=0,type=0
    	fmt.Printf("len=%d,cap=%d,type=%d\n", len(b), cap(b), bs.Data) //len=0,cap=0,type=18212960
    }

可以看到var a\[\]int 创建的切片是一个nil切片（底层数据没有分配，指针指向nil），数据结构如下：  
![在这里插入图片描述][6423e201292441ab9d8cf80e8e774a64.png]  
可以看到make(\[\]int, 0)创建的是一个空切片（底层数组指针费控，但底层数据是空的），数据结构如下：  
![在这里插入图片描述][6e5921b9e4c0422bbe5f54d0d5311658.png]  
看一下makeslice底层实现代码，就是到为什么make(\[\]int, 0)创建的是一个空切片：

func makeslice(et *_type, len, cap int) slice {
        
    	maxElements := maxSliceCap(et.size)
    	if len < 0 || uintptr(len) > maxElements {
        
    		panic(errorString("makeslice: len out of range"))
    	}
    
    	if cap < len || uintptr(cap) > maxElements {
        
    		panic(errorString("makeslice: cap out of range"))
    	}
    	//调用mallocgc分配空间
    	p := mallocgc(et.size*uintptr(cap), et, true)
    	return slice{
        p, len, cap}
    }

接下来看一下len和cap是0的情况下，mallocgc的代码片段

func mallocgc(size uintptr, typ *_type, needzero bool) unsafe.Pointer {
        
    	if gcphase == _GCmarktermination {
        
    		throw("mallocgc called with gcphase == _GCmarktermination")
    	}
    
    	if size == 0 {
        
    		return unsafe.Pointer(&zerobase)
    	}
    ...
    
    }

##### 多个切片引用同一个底层数组引发的混乱 #####

切片可以由数组创建，一个底层数组可以创建多个切片，这些切片共享底层数组，使用append扩展切片过程中可能修改底层数组的元素，间接地影响其他切片的值，也可能发生数组复制重建，共用底层数组的切片，由于其行为不明朗，不推荐使用。接下来看一个示例：

package main
    
    import (
    	"fmt"
    	"reflect"
    	"unsafe"
    )
    
    func main() {
        
    	a := []int{
        0, 1, 2, 3, 4, 5, 6}
    	b := a[0:4]
    
    	as := (*reflect.SliceHeader)(unsafe.Pointer(&a))
    	bs := (*reflect.SliceHeader)(unsafe.Pointer(&b))
    
    	//a、b共享底层数组
    	fmt.Printf("a=%v,len=%d,cap=%d,type=%d\n", a, len(a), cap(a), as.Data)
    	fmt.Printf("b=%v,len=%d,cap=%d,type=%d\n", b, len(b), cap(b), bs.Data)
    
    	b = append(b, 10, 11, 12)
    	//a、b继续共享底层数组，修改b会影响共享的底层数组，间接影响
    	fmt.Printf("a=%v,len=%d,cap=%d\n", a, len(a), cap(a))
    	fmt.Printf("b=%v,len=%d,cap=%d\n", b, len(b), cap(b))
    
    	//1en(b)=7,底层数组容量是7，此时需要重新分配数组，并将原来数组值复制到新数组
    	b = append(b, 13, 14)
    	as = (*reflect.SliceHeader)(unsafe.Pointer(&a))
    	bs = (*reflect.SliceHeader)(unsafe.Pointer(&b))
    
    	//可以看到a和b指向底层数组的指针已经不同了
    	fmt.Printf("a=%v,len=%d,cap=%d,type=%d\n", a, len(a), cap(a), as.Data)
    	fmt.Printf("a=%v,len=%d,cap=%d,type=%d\n", b, len(b), cap(b), bs.Data)
    }
    
    //结果
    a=[0 1 2 3 4 5 6],len=7,cap=7,type=842350559488
    b=[0 1 2 3],len=4,cap=7,type=842350559488
    a=[0 1 2 3 10 11 12],len=7,cap=7
    b=[0 1 2 3 10 11 12],len=7,cap=7
    a=[0 1 2 3 10 11 12],len=7,cap=7,type=842350559488
    a=[0 1 2 3 10 11 12 13 14],len=9,cap=14,type=842350837872

问题总结：多个切片共享一个底层数组，其中一个切片的append操作可能引发如下两种情况。

1.  append追加的元素没有超过底层数组的容量，此种append操作会直接操作共享的底层数组，如果其他切片有引用数组被覆盖的元素，则会导致其他切片的值也隐式地发生变化。
2.  append追加的元素加上原来的元素如果超出底层数组的容量，则此种append操作会重新申请新数组，并将原来数组值复制到新数组。由于有这种二义性，所以在使用切片的过程中应该尽量避免多个切面共享底层数组，可以使用copy进行显式的复制。

[dffe1b58f5ee4e75881e627ed0284fb3.png]: https://img-blog.csdnimg.cn/dffe1b58f5ee4e75881e627ed0284fb3.png
[5614b71a9df44f0abc344b14763698da.png]: https://img-blog.csdnimg.cn/5614b71a9df44f0abc344b14763698da.png
[6423e201292441ab9d8cf80e8e774a64.png]: https://img-blog.csdnimg.cn/6423e201292441ab9d8cf80e8e774a64.png
[6e5921b9e4c0422bbe5f54d0d5311658.png]: https://img-blog.csdnimg.cn/6e5921b9e4c0422bbe5f54d0d5311658.png