go 切片底层 Go语言Slice切片底层的实现 go 切片参数

1.切片是什么

在Go语言中切片（slice）是建立在数组之上的一种抽象类型。切片提供了一种更灵活的方式来处理数组、它允许动态地改变数组的大致、并且可以方便地进行切片操作。领会切片之前、我们需要先了解数组。

Go的数组在Go语言中、数组的长度是类型的一部分、由此可见数组的长度是固定的、不能改变。

数组的传递和拷贝行为与C语言不同、Go语言中的数组是值类型、传递数组时会进行值拷贝。

1.1 示例一：

将数组传递到函数中数组的地址不一样

package mainimport “fmt”func main() array := [3]int1, 2, 3} // 数组传递到函数中 test(array) fmt.Printf(“array 外: %pn”, &array)}func test(array [3]int) fmt.Printf(“array 内: %pn”, &array) }

由于数组是值类型、传递数组时会进行值拷贝、因此在test函数中打印的地址与main函数中打印的地址不同。

1.2 值拷贝

值拷贝意味着拷贝的是变量的内容、而不是内存地址。因此拷贝出来的变量有自己的独立副本、内容相同、但它们存储在不同的内存地址中。

Go 语言中的切片（slice）是动态扩容的。当你向切片中添加元素时、Go 会自动管理切片的大致、并在需要时进行扩容。

具体行为：

初始容量：当你创建一个切片时、Go 会为切片分配一个初始容量。如果你添加的元素超过了切片当前的容量Go 会自动扩容。
扩容制度：Go 会根据当前切片的容量自动扩展切片的大致、通常是原来容量的2倍。扩容后、切片的长度和容量都会增加。
内部机制：当切片扩容时、Go 会为新切片分配新的底层数组、并将原数组的元素拷贝到新数组中。这一个代价比较高的操作、尤其是在需要多次扩容的情况下

2.底层结构

type slice struct // 底层数组指针（或者说是指向一块连续内存空间的起点） array unsafe.Pointer // 长度 len int // 容量 cap int}

在这个结构中：

array：指向底层数组的指针、或者说是指向一块连续内存空间的起点。
len：切片的长度、即切片中实际包含的元素数量。
cap：切片的容量、即切片可以包含的元素的最大数量，不包括可能的扩展空间。

切片扩容

计算目标容量

case1:如果新切片的长度大于旧切片容量的两倍、则新切片容量就为新切片的长度。

case2:

如果旧切片的容量小于256、那么新切片的容量就是旧切片的容量的两倍。
反之需要用旧切片容量按照1.25倍的增速、直到大于新切片长度。

为了更平滑的过渡、每次扩大1.25倍、还会加上3/4 * 256

进行内存对齐、需要按照Go内存管理的级别去对齐内存、最终容量以这个为准。

3.切片难题

3.1 切片通过函数传的是什么

package mainimport ( “fmt” “reflect” “unsafe”)func main() s := make([]int, 5, 10) PrintSliceStruct(&s) test(s)}func test(s []int) PrintSliceStruct(&s)}func PrintSliceStruct(s *[]int) // 代码将slice 转换成 reflect.SliceHeader ss := (*reflect.SliceHeader)(unsafe.Pointer(s)) // 查看slice的结构 fmt.Printf(“slice struct: %+v, slice is %vn”, ss, s)}

控制台输出：

slice struct: &Data:1374389649568 Len:5 Cap:10}, slice is &[0 0 0 0 0]
slice struct: &Data:1374389649568 Len:5 Cap:10}, slice is &[0 0 0 0 0]

切片的定义：你创建了一个切片 s、通过 make([]int, 5, 10) 创建了一个长度为 5、容量为 10 的切片。

也就是说它初始化了一个包含 5 个元素且最大容量为 10 的底层数组

划重点：

切片传递：当切片通过参数传递到函数时、传递的是切片的值、但切片内部的底层数组地址（指针）并没有被复制。

PrintSliceStruct打印的结构：无论是在 main 函数还是 test 函数中、切片的底层数组地址、长度和容量都是相同的、由于底层数组是共享的。

为什么输出相同：

输出显示的 Data 地址、Len 和 Cap 是一致的、由于 test(s) 传递的是切片的值（即切片的结构），但切片中的指针指向相同的底层数组。因此无论是传递给PrintSliceStruct函数的 s、还是 test 函数中的 s、它们指向的是同一个底层数组、并且它们的长度和容量保持一致

3.2 在函数里面改变切片函数外的切片会被影响吗

package mainimport ( “fmt” “reflect” “unsafe”)func main() s := make([]int, 5) // 创建一个长度为 5 的切片 case1(s) // 调用 case1 函数 case2(s) // 调用 case2 函数 PrintSliceStruct(&s) // 打印切片结构}// 底层数组不变func case1(s []int) s[1] = 1 // 修改切片中的元素 PrintSliceStruct(&s) // 打印切片结构}// 底层数组变化func case2(s []int) s = append(s, 0) // 扩容切片 s[1] = 1 // 修改切片中的元素 PrintSliceStruct(&s) // 打印切片结构}func PrintSliceStruct(s *[]int) // 将切片转换成 reflect.SliceHeader ss := (*reflect.SliceHeader)(unsafe.Pointer(s)) // 打印切片的底层结构 fmt.Printf(“slice struct: %+v, slice is %vn”, ss, *s)}

关键点：

case1函数：

在case1中、你传入一个长度为 5 的切片 s、并修改切片中的元素。

切片在函数内的操作是对原切片的修改、因此底层数组没有发生变化、切片的容量、长度仍然相同。

打印的slice struct的 Data、Len和Cap字段显示的是切片的原始底层数据结构。

case2函数：

在case2中、你向切片添加一个元素（通过 append 操作）、这将可能导致切片的底层数组扩容。

由于append操作在超出当前容量时会触发扩容、因此 s 的底层数组会发生变化、容量也可能增加。

在case2中、s 被赋值为 append(s, 0)、这将导致原有切片 s 的底层数组被扩展、并且一个新的数组被分配给 s（s 指向的是新的底层数组）

打印时会看到slice struct中的 Data 指向一个新的地址、表示底层数组已经发生了变化。

append(s, 0)函数会检查切片s是否有足够的容量来存储新的元素。如果切片的容量不足、append函数会分配一个新的更大的数组、并复制旧数组的内容到新数组中、接着将新元素添加到新数组的末尾、并更新切片的指针以指向包含新元素的新底层数组。

3.3 截取切片

package mainimport ( “fmt” “reflect” “unsafe”)func main() s := make([]int, 5) // 创建一个长度为 5 的切片，默认初始化为 [0 0 0 0 0] case1(s) // 调用 case1，修改切片内容 case2(s) // 调用 case2，修改切片并改变底层数组 case3(s) // 调用 case3，截取切片并改变其长度 case4(s) // 调用 case4，截取切片的部分元素 PrintSliceStruct(&s) // 最终打印切片的底层结构}// case1：修改切片元素、底层数组不变func case1(s []int) s[1] = 1 // 修改切片中的第二个元素，s[1] = 1 PrintSliceStruct(&s) // 打印修改后的切片底层结构}// case2：重新赋值为新的切片func case2(s []int) s = s[:] // 这里实际上并没有改变切片的内容、它只是重新赋值为原切片的一个新引用。 PrintSliceStruct(&s) // 打印新的切片底层结构}// case3：截取切片、底层数组不变func case3(s []int) s = s[:len(s)-1] // 截取切片、去掉最终一个元素、新的切片长度为 4 PrintSliceStruct(&s) // 打印截取后的切片底层结构}// case4：截取切片的部分元素、底层数组不变func case4(s []int) sl := s[1:2] // 截取 s[1:2]，即取出切片中索引为 1 的元素 PrintSliceStruct(&sl) // 打印截取后的新切片底层结构}// PrintSliceStruct 打印切片的底层结构func PrintSliceStruct(s *[]int) // 将切片的指针转换为 reflect.SliceHeader 结构体，通过 unsafe.Pointer 获取底层数据 ss := (*reflect.SliceHeader)(unsafe.Pointer(s)) // 打印切片的底层数据结构、包括：指向底层数组的内存地址、切片的长度和容量 fmt.Printf(“slice struct: %+v, slice is %vn”, ss, *s)}

划重点：

切片操作的影响：

修改切片元素不会改变底层数组的地址。

重新赋值切片并没有改变底层数组、除非涉及扩容（例如 append）。

截取切片时、底层数组不变、切片的长度和容量可能会变化。

3.4 删除元素

package mainimport ( “fmt” “reflect” “unsafe”)func main() // 创建一个包含5个整数的切片 s := []int0, 1, 2, 3, 4} // 打印切片的底层结构 PrintSliceStruct(&s) // 删除切片中的最终一个元素，正确的行为是通过切片截取 _ = s[4] // 访问并丢弃切片中的最终一个元素 s1 := append(s[:1], s[2:]…) // 删除元素 s[1]， //s[:1]（即切片 [0]）和 s[2:]（即切片 [2, 3, 4]）拼接在一起。 // 打印修改后的切片 fmt.Println(s) // [0 2 3 4 4] fmt.Println(s1) // [0, 2, 3, 4] // 打印切片底层结构 PrintSliceStruct(&s) PrintSliceStruct(&s1) // 访问切片的元素 s = s[:4] // 截取切片、删除最终一个元素 _ = s[3] // 访问切片中的最终一个元素（索引为3的元素）}// 打印切片的底层结构func PrintSliceStruct(s *[]int) // 将切片转换为 reflect.SliceHeader ss := (*reflect.SliceHeader)(unsafe.Pointer(s)) // 打印切片的底层结构 fmt.Printf(“slice struct: %+v, slice is %vn”, ss, *s)}

在 Go 中、切片操作需要特别注意切片的索引和截取。访问切片中的元素时要小心类型不匹配（例如不能将一个切片元素赋值给切片）。

控制台输出：

slice struct: &Data:1374390755328 Len:5 Cap:5}, slice is [0 1 2 3 4]
[0 2 3 4 4]
[0 2 3 4]
slice struct: &Data:1374390755328 Len:5 Cap:5}, slice is [0 2 3 4 4]
slice struct: &Data:1374390755328 Len:4 Cap:5}, slice is [0 2 3 4]

打印原切片 s 时、它仍然指向原底层数组（长度为 5、容量为 5）、而且由于 s[4] 在内存中并没有被移除、原底层数组中的最终一个元素 4 被保留、因此 s 显示为 [0 2 3 4 4]。

简而言之s 显示为 [0 2 3 4, 4] 是由于原始切片的底层数组并没有被修改、而append操作生成了一个新的切片（s1）并分配了新的底层数组。因此s 中仍然包含原数组中的所有元素、最终一个 4 仍然存在。

为什么s变成了[0, 2, 3, 4, 4]

append 会根据切片的容量决定是否会使用原来的底层数组。如果原切片的容量足够大、append 就会直接修改原切片。

在这段代码中、由于原始切片 s 的容量足够大（原始切片 s 的容量为 5）、append 仍然修改了原始切片 s 的内容。切片的 s 和 s1 都指向相同的底层数组。

重点：

原切片 s 的容量没有改变：s 底层的数组仍然包含原来 s 的所有元素。

append 没有重新分配新的底层数组：由于原切片的容量足够、因此 append 在修改原底层数组时、并没有创建新的底层数组。因此原始切片 s 中的 4 仍然存在。

修改后 s 中的元素为 [0, 2, 3, 4, 4]：虽然你删除了 s[1] 这个元素、但 append 使得 s 的底层数组没有发生变化，因此原始的 4 元素仍然保留在切片中。

重点拎出来说：

append操作有时会创建新的底层数组（如果容量不足）、但如果原切片的容量足够、append 直接修改原切片的底层数组。在这种情况下原切片 s 会保持原来的容量和数据、导致 s 显示为 [0, 2, 3, 4, 4]，即最终一个 4 保留下来了。

3.5 新增元素

package mainimport ( “fmt” “reflect” “unsafe”)func main() case1() case2() case3()}// case1 函数展示了使用 append 在切片末尾添加元素的行为func case1() // 创建一个长度为 3，容量为 3 的切片 s1 := make([]int, 3, 3) // 向切片添加一个元素 1，append 返回一个新的切片 s1 = append(s1, 1) // 打印切片的底层结构 PrintSliceStruct(&s1) //1}// case2 函数展示了在原切片上使用 append 并打印切片结构的变化func case2() // 创建一个长度为 3，容量为 4 的切片 s1 := make([]int, 3, 4) // 向切片添加一个元素 1，append 会扩展切片的长度 s2 := append(s1, 1) // 打印原切片 s1 和新切片 s2 的底层结构 PrintSliceStruct(&s1)//2 PrintSliceStruct(&s2)//3}// case3 函数与 case2 类似，展示了切片长度、容量变化的行为func case3() // 创建一个长度为 3，容量为 3 的切片 s1 := make([]int, 3, 3) // 向切片添加一个元素 1，append 返回一个新的切片 s2 := append(s1, 1) // 打印原切片 s1 和新切片 s2 的底层结构 PrintSliceStruct(&s1)//4 PrintSliceStruct(&s2)//5}// PrintSliceStruct 打印切片的底层结构func PrintSliceStruct(s *[]int) // 使用 reflect 和 unsafe 包将切片转换成 reflect.SliceHeader 结构体 ss := (*reflect.SliceHeader)(unsafe.Pointer(s)) // 打印切片的底层结构 fmt.Printf(“slice struct: %+v, slice is %vn”, ss, *s)}

控制台输出

slice struct: &Data:1374390755328 Len:4 Cap:6}, slice is [0 0 0 1]
slice struct: &Data:1374390779936 Len:3 Cap:4}, slice is [0 0 0]
slice struct: &Data:1374390779936 Len:4 Cap:4}, slice is [0 0 0 1]
slice struct: &Data:1374390673552 Len:3 Cap:3}, slice is [0 0 0]
slice struct: &Data:1374390755376 Len:4 Cap:6}, slice is [0 0 0 1]

case1:

使用 make([]int, 3, 3) 创建了一个长度为 3，容量为 3 的切片 s1，初始内容为 [0, 0, 0]。

接着append(s1, 1)会将元素 1 添加到切片的末尾、生成一个新的切片并返回。由于容量是 3、append会自动扩容新的切片长度是 4

最终调用PrintSliceStruct打印 s1 切片的底层结构。

case2:

make([]int, 3, 4)创建了一个长度为 3、容量为 4 的切片 s1

使用append(s1, 1)向切片添加元素 1、生成一个新切片 s2。由于 s1 的容量已足够、不会触发扩容。

通过PrintSliceStruct打印切片 s1 和 s2 的底层结构。

s3 和 s4 参考上面

3.6 操作原来切片会影响新的切片吗

在 Go 中、切片是引用类型，由此可见当你创建一个新切片时，它实际上可能会指向同一个底层数组。因此，如果你修改了原切片（比如通过 append 或其他操作），它可能会影响到新切片，特别是在底层数组没有被重新分配的情况下。

切片和底层数组

切片（slice）一个非常轻量级的抽象，它包含了三个部分：指向底层数组的指针、切片的长度和切片的容量。

当你对切片进行操作时（例如使用 append、copy 或直接修改），这些操作通常会影响到底层数组。

如果多个切片引用同一个底层数组，改变其中一个切片的内容可能会影响到其他切片，尤其是在没有扩容时。

append操作

当使用 append 函数时、如果切片的容量足够、append 会直接在原底层数组上操作、不会创建新的底层数组。在这种情况下、修改原切片的内容会影响到新切片、由于它们指向相同的底层数组。

如果容量不足、append 会创建一个新的底层数组、并将原切片的数据复制到新数组中、这时原切片和新切片就指向不同的底层数组了、它们互不影响。

例子：

没有扩容：

s1 := []int1, 2, 3}s2 := s1 // s2 指向与 s1 相同的底层数组s1[0] = 100 // 修改 s1 中的第一个元素fmt.Println(s1) // 输出 [100, 2, 3]fmt.Println(s2) // 输出 [100, 2, 3]

这里s1 和 s2 指向相同的底层数组，因此修改 s1 会影响到 s2。

扩容时：

s1 := []int1, 2, 3}s2 := append(s1, 4) // s2 创建了新的底层数组s1[0] = 100 // 修改 s1 中的第一个元素fmt.Println(s1) // 输出 [100, 2, 3]fmt.Println(s2) // 输出 [1、2、3、 4]

这里s2 创建了一个新的底层数组，因此修改 s1 不会影响 s2。

重点拎出来说：

修改原切片会影响新切片：如果新切片是通过引用原切片的底层数组创建的（没有触发扩容）、修改原切片的内容会影响到新切片。

扩容时不影响：如果 append 或其他操作导致了扩容、原切片和新切片就会指向不同的底层数组、互不影响。

4.字节面试题

下面这道题的输出是什么

package mainimport “fmt”func main() // 定义一个匿名函数 doAppend，用来执行 append 操作并打印切片的长度和容量 doAppend := func(s []int) s = append(s, 1) // 向切片中添加元素 1 printLengthAndCapacity(s) // 打印切片的长度和容量 } // 创建一个长度为 8，容量为 8 的切片 s s := make([]int, 8, 8) // 传递 s 的前 4 个元素（即 s[:4]）到 doAppend doAppend(s[:4]) // 只传递前4个元素的切片 // 打印原始切片 s 的长度和容量 printLengthAndCapacity(s) // 传递整个切片 s 到 doAppend doAppend(s) // 打印原始切片 s 的长度和容量 printLengthAndCapacity(s)}func printLengthAndCapacity(s []int) fmt.Println() fmt.Printf(“len=%d cap=%d n”, len(s), cap(s)) // 打印切片的长度和容量}

len(s) 是切片的长度。

cap(s) 是切片的容量、表示切片底层数组的大致。

len=5 cap=8 len=8 cap=8 len=9 cap=16 len=8 cap=8

调用doAppend(s[:4])：

s[:4] 是 s 切片的前 4 个元素、创建一个新的切片 [0, 0, 0, 0]，长度为 4、容量为 8（由于它引用的是原切片的底层数组）。

在 doAppend 中、执行 append(s, 1)、这会向切片添加一个元素 1、导致切片的长度变为 5、容量保持为 8（由于它没有触发扩容）。

打印结局为：len=5 cap=8。

调用 doAppend(s)：

这次传递整个 s 切片、长度为 8、容量为 8。

执行append(s 1)、这会向切片 s 添加一个元素 1。由于 s 的容量是 8、不能再容纳更多元素、因此会触发扩容、新的底层数组的容量将是原来的 2 倍、即 16、长度变为 9。

打印结局为：len=9 cap=16。

注意：

append 创建了一个新的底层数组、并返回了一个新的切片。如果你不把返回的新切片赋值回 s、原始切片 s 不会改变、仍然指向旧的底层数组。

由于 append(s 1) 返回的一个新的切片、但并没有将它赋值回 s、因此原始切片 s 的长度和容量没有变化、仍然是 len=8 和 cap=8

如果改成将新切片赋值回s

package mainimport “fmt”func main() // 定义一个匿名函数 doAppend 用于向切片添加元素 doAppend := func(s []int) s = append(s, 1) // 向切片中添加元素 1 printLengthAndCapacity(s) // 打印切片的长度和容量 } // 定义一个匿名函数 doAppend 用于向切片添加元素 doAppends := func(s []int) []int s = append(s, 1) // 使用 append 向切片添加一个元素 1 printLengthAndCapacity(s) return s } // 创建一个长度为 8，容量为 8 的切片 s s := make([]int, 8, 8) // 传递前 4 个元素的切片 doAppend(s[:4]) // 只传递前4个元素的切片 printLengthAndCapacity(s) // 传递整个切片 s s = doAppends(s) // 将返回的新切片赋值回 s printLengthAndCapacity(s)}func printLengthAndCapacity(s []int) fmt.Println() fmt.Printf(“len=%d cap=%d n”, len(s), cap(s))}

len=5 cap=8
len=8 cap=8
len=9 cap=16
len=9 cap=16

到此这篇关于Go语言Slice切片底层的实现的文章就介绍到这了,更多相关Go语言Slice切片内容请搜索风君子博客以前的文章或继续浏览下面的相关文章希望大家以后多多支持风君子博客！

无论兄弟们可能感兴趣的文章:

深入解析Go语言编程中slice切片结构
Go语言&8211;切片(Slice)详解
Go语言里切片slice的用法介绍
GO语言的数组array与切片slice详解
Go语言中切片(slice)和数组(array)的区别详解
go语言切片slice使用细节和注意事项整理大全
Go语言切片(Slice)深度剖析与应用实战

go 切片底层 Go语言Slice切片底层的实现 go 切片参数

目录

1.切片是什么

1.1 示例一：

1.2 值拷贝

2.底层结构

切片扩容

3.切片难题

3.1 切片通过函数传的是什么

3.2 在函数里面改变切片函数外的切片会被影响吗

3.3 截取切片

3.4 删除元素

3.5 新增元素

3.6 操作原来切片会影响新的切片吗

4.字节面试题

如果改成将新切片赋值回s

您可能感兴趣

目录

1.切片是什么

1.1 示例一：

1.2 值拷贝

2.底层结构

切片扩容

3.切片难题

3.1 切片通过函数传的是什么

3.2 在函数里面改变切片 函数外的切片会被影响吗

3.3 截取切片

3.4 删除元素

3.5 新增元素

3.6 操作原来切片会影响新的切片吗

4.字节面试题

如果改成将新切片赋值回s

您可能感兴趣

3.2 在函数里面改变切片函数外的切片会被影响吗