【Golang】Slice数组组成和扩容机制

最新推荐文章于 2024-04-23 19:43:22 发布
最新推荐文章于 2024-04-23 19:43:22 发布
阅读量1.7k 收藏 1
点赞数 3
分类专栏： golang 文章标签： golang 开发语言 后端 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_46305978/article/details/123380358
版权

Golang Slice 结构体

写这个的初衷是因为看到一个 b站的UP主（幼麟实验室）做 Golang 的视频有感而生，想通过视频深入剖析一下内容，顺便当作一个输出，记录自己学习的过程。

up主的连接如下：幼麟实验室

Slice 结构体

在 Golang 里面，Slice的结构体如下所示：
Slice结构体
第一个成员为指向底层数组的指针，第二个为该切片的长度，第三个为底层数组的容量。简单的解释就是，len为这个Slice结构体可以获取数据的最大位置，而cap为指向的底层数组的实际容量。以下为slice的结构体定义：

// runtime/slice.go
type slice struct {
	array unsafe.Pointer
	len   int
	cap   int
}

通过下面的方式来定义一个整数切片

var ints []int

此时，ints切片的data部分为nil，长度为0，容量为0。具体结构如[nil, 0, 0]。如果此时使用make为ints开辟一个空间，如下图所示：

ints = make([]int, 2) // len = 2

make第一个参数为数组类型，第二个为切片长度。但是如果此时加入第三个参数，如下所示：

ints = make([]int, 2,5) // len = 2. cap = 5

第三个参数为切片的容量。所以，用户是可以自定义该切片的容量的。你们也可以通过如下实验来检测这个的正确性。

import "fmt"

func main() {
	var ints []int
	ints = make([]int, 2)
	fmt.Println(" len: ", len(ints), " cap: ", cap(ints))

	ints = make([]int, 2, 5)
	fmt.Println(" len: ", len(ints), " cap: ", cap(ints))
}

output
>>> len: 2 cap: 2
>>> len: 2 cap: 5

刚刚已经知道，len为切片的最大可访问位置，如果我们执行以下代码，就会发生panic。

func main() {
	var ints []int
	ints = make([]int, 2, 5)
	fmt.Println("len:", len(ints), "cap:", cap(ints))

	fmt.Println(ints[2])
}

output
>>> len: 2 cap: 2
>>> panic: runtime error: index out of range [2] with length 2

如果上述ints变量我们使用 new 来进行初始化呢，操作如下：

ints := new([]int)

此时，ints为一个指针，指向的是 slice 结构的起始地址，效果如下所示：
在这里插入图片描述
此时，ints指向一个data为nil的空的切片。此时，如果想要为ints指向的切片开辟地址空间，可以使用append方法。如下：

ints = append(ints, 1)

此时，ints指向的切片就会变成[data, 1, 1]，data为指向底层数组的指针，长度为1，容量为1。通过如下实验可以证明这个结果：

func main() {
	ints := new([]int)
	fmt.Println(&ints)
	fmt.Println("len:", len(*ints), "cap:", cap(*ints))

	*ints = append(*ints, 1)
	fmt.Println("len:", len(*ints), "cap:", cap(*ints))
}

output
>>> 0xc0000ce018
>>> len: 0 cap: 0
>>> len: 1 cap: 1

第一个输出可以看出，ints是一个指针，此时通过指针访问切片可以知道，该切片长度为0，容量为0。通过append添加元素之后，切片长度变为1，容量也为1。

Slice 结构体获取“子”切片

使用过 python 的都知道，python 数组可以直接通过索引来获得子数组，如下所示：

nums = [0,1,2,3,4]
sub = nums[1:3]
print(sub)

output
>>> [1,2]

golang 中，切片也可以通过如下的方式来获取子数组。

ints := [10]int{1,2,3,4,5,6,7,8,9,10}
var s1 = ints[1:4]
var s2 = ints[7:]

通过这个方法得到的s1，s2切片的底层数组指向的是ints数组。
对数组进行切片
在生成切片时，切片的长度为我们定义的长度[1:4]即为3，而切片的指针指向目标的起始位置。s1为arr从索引1到索引3的数据，所以data指向arr[1]的地址，而容量则为起始位置到该底层数组的结束位置的大小，即[1-9]总共为9。s2也同理。通过如下的实验可以验证这个场景。

func main() {
	arr := [10]int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
	for i := 0; i < 10; i++ {
		println(&arr[i])
	}
	println("=====================")
	
	var s1 []int = arr[1:4]
	var s2 []int = arr[7:]

	a1 := &s1[0]
	println(a1)
	a2 := &s2[0]
	println(a2)
}

output
>>> 0xc000077f20
>>> 0xc000077f28
>>> 0xc000077f30
>>> 0xc000077f38
>>> 0xc000077f40
>>> 0xc000077f48
>>> 0xc000077f50
>>> 0xc000077f58
>>> 0xc000077f60
>>> 0xc000077f68
>>> =====================
>>> 0xc000077f28
>>> 0xc000077f58

本次使用的电脑为64位的，所以int的大小为8个字节。可以看出，arr数组的各个元素之间的地址确实是差8个字节。分割线之后的第一个为s1底层数组指向的位置，0xc000077f28为arr[1]的地址，而0xc000077f58为arr[7]的位置。

重点

如果此时对s1切片进行扩容，s1的切片结构就会从[data, 3, 9]变成[data, 4, 9]。而此时，s1的指针依旧还是在arr[1]的位置上，但是此时append添加的元素就会修改在arr数组上。代码如下：

func main() {
	arr := [10]int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
	fmt.Println(arr)

	println("=====================")

	var s1 []int = arr[1:4]
	fmt.Println(&s1[0], " len: ", len(s1), " cap: ", cap(s1))

	s1 = append(s1, 1)
	fmt.Println(&s1[0], " len: ", len(s1), " cap: ", cap(s1))
	
	println("=====================")
	fmt.Println(arr)
}

output
>>> [0 1 2 3 4 5 6 7 8 9]
>>> =====================
>>> 0xc0000b00a8  len:  3  cap:  9
>>> 0xc0000b00a8  len:  4  cap:  9
>>> =====================
>>> [0 1 2 3 1 5 6 7 8 9]

可以看出，扩容前扩容后的数组指向的都为arr[1]的地址位置，但是此时如果对s1进行扩容，因为扩容后长度仍小于容量，所以slice不会重新创建一个新的数组，而此时扩容放入的1就被赋值在了arr[4]这个位置上。此时就会对原数组数据进行修改，造成数据不安全。但是，如果扩容后的长度大于容量的话，slice就会创建一个新的数组，并将值赋值到新的底层数组上。

func main() {
	arr := [10]int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
	fmt.Println(arr)

	println("=====================")

	var s1 []int = arr[7:]
	fmt.Println(&s1[0], " len: ", len(s1), " cap: ", cap(s1))

	s1 = append(s1, 1)
	fmt.Println(&s1[0], " len: ", len(s1), " cap: ", cap(s1))

	println("=====================")
	fmt.Println(arr)
	println("=====================")
	fmt.Println(s1)
}

output
>>> [0 1 2 3 4 5 6 7 8 9]
>>> =====================
>>> 0xc0000b00d8  len:  3  cap:  9
>>> 0xc0000c0090  len:  4  cap:  6
>>> =====================
>>> [0 1 2 3 4 5 6 7 8 9]
>>> =====================
>>> [7 8 9 1]

可以看出，此时扩容前后数组的底层数组位置发生了变化，且增加不再影响原来的数组了。

Slice 结构体扩容机制

从上文最后一个实验可以看出，s2在扩容之后，容量不是从3 -> 4，而是变成了6。那么，slice是如何预估扩容之后的容量呢。
slice结构体的扩容代码如下：

// runtime/slice.go
func growslice(et *_type, old slice, cap int) slice {
	//...
	newcap := old.cap
	doublecap := newcap + newcap
	if cap > doublecap {
		newcap = cap
	} else {
		if old.cap < 1024 {
			newcap = doublecap
		} else {
			//...
			for 0 < newcap && newcap < cap {
				newcap += newcap / 4
			}
		}
	}
	//...
}

简而言之，如果newcap > 2 * oldcap（注意，此时这个newcap和上文代码中的newcap表达不一致，本文的newcap就是新容量的意思），那么直接将容量设置为新容量。举下面这个例子：

ints := make([]int, 2)
ints = append(ints, 2, 3, 4)

原来的容量为2，新容量为5，因为2 * 2 < 5，所以此时新的容量为5。
否则，如果oldcap < 1024，则直接将容量翻倍，如果大于1024则放大1.25倍。

short_ints := make([]int, 2)
short_ints = append(ints, 2) // 这个为翻倍

long_ints := make([]int, 2048)
long_ints = append(ints, 2) // 这个为 1.25 倍

但是可能会问了，上文的实验中，最后的实验产生的s2容量为6，并不是5。这个是因为，golang 在分配内存空间的时候，不会按照需要的大小去给对应的大小，而是会从内存管理模块中获取一个足够大且大小最相近的内存。因为，golang 在运行时，会预先向系统申请一部分内存，然后按照不同大小，分类缓存起来，等到需要的时候申请即可。此时不对此内容进行深究，需要的话可以看这个博主的博文。博文地址

在扩容时，申请的内存大小为新容量 * 类型大小，在如下这个实验中：

ints := make([]int, 2)
ints = append(ints, 2, 3, 4)

新的容量为5，类型大小为8个字节，所以所需的内存大小为40个字节。而实际申请时，会匹配到48字节的大小，48个字节正好是容量为6的int数组的大小，所以显示出来容量为6。通过如下实验获取结果：

func main() {
	ints := make([]int, 2)
	fmt.Println(&ints[0], " len: ", len(ints), " cap: ", cap(ints))
	ints = append(ints, 2, 3, 4)
	fmt.Println(&ints[0], " len: ", len(ints), " cap: ", cap(ints))

	println("=====================")

	ints2 := make([]int, 2)
	fmt.Println(&ints2[0], " len: ", len(ints2), " cap: ", cap(ints2))
	ints2 = append(ints2, 2)
	fmt.Println(&ints2[0], " len: ", len(ints2), " cap: ", cap(ints2))

	println("=====================")

	ints3 := make([]int, 1024)
	fmt.Println(&ints3[0], " len: ", len(ints3), " cap: ", cap(ints3))
	ints3 = append(ints3, 2)
	fmt.Println(&ints3[0], " len: ", len(ints3), " cap: ", cap(ints3))
}

output
>>> =====================
>>> 0xc0000180a0  len:  2  cap:  2
>>> 0xc00000a360  len:  5  cap:  6
>>> =====================
>>> 0xc0000180d0  len:  2  cap:  2
>>> 0xc00000e200  len:  3  cap:  4
>>> =====================
>>> 0xc00007c000  len:  1024  cap: 1024
>>> 0xc000100000  len:  1025  cap: 1280

从上面的第二个输出可以看出，容量满足翻倍的条件，进行了翻倍，同时匹配到的内存规格为32字节的，所以此时容量为4。而容量大于等于1024，则增长了1.25倍，且内存规格为1280（1280也正好是1024的1.25倍）。

但是可以发现ints2和ints的内存地址是相同的，不知道是不是 golang 对这个做了些优化，目前我还不清楚，如果有知道的朋友也请告诉我。

最后

不得不说，前面提到的 UP 主做的视频真的很适合 golang 开发者，但是可能需要有一定理解再去看会比较有收获。还有就是，打博文太难了…

深大呆头鹅
关注
  • 3
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Golang底层总结
qq_61465103的博客
04-27 3102
Golang题目总结
Golang数组和切片区别及切片扩容
turbock的博客
05-17 1043
1. 内部结构 1.1. 数组 Array 先说一下数组, 的确在 Go 语言中, 因为 slice 的存在, 使得 array 的出场率不高。但想要很好的理解 slice, 还是要先要了解 array. Go 语言的数组和其他语言一样, 没有什么特别的地方, 就是一段以元素类型(如int)为单位的连续内存空间。数组创建时, 被初始化为元素类型的零值. 声明举例: var arr [10]int // 长度为 10 的数组, 默认所有元素是 0 arr := [...]int{1, 2, 3} // 长度
Golang深入浅出之-切片（Slices）入门：创建、操作与扩容机制
最新发布
zevjay的博客
04-23 587
切片（Slices）是Go语言中处理数组的灵活工具，提供了动态大小、灵活操作和自动扩容等功能。本文将深入浅出地介绍Go语言切片的创建、基本操作以及扩容机制，同时揭示相关常见问题与易错点，并通过代码示例进行说明。
golang slice扩容
小小程序员
05-15 748
很多程序员对于slice的使用，都是直接append，有没有人考虑过批量append和单个连续append有什么区别？ 对于cap的申请有什么规则？ 很多人都说slice容量小于1024，扩容是双倍扩容，大于1024是1.25倍扩容，这句话有没有道理呢？ 还别说在一定条件是这句话是没有问题的。直接上代码： package main import "fmt" // 扩容规则 // 字节大小：1024 * 1.25 * 8 = 10240 cap：10240/8 = 1280 超过1024的话，1.2
go语言slice是怎么扩容的？
byteinit的专栏
02-20 614
Go 语言的切片扩容机制是在需要时自动进行的，它可以保证切片能够容纳足够多的元素。在 Go 1.8 之后，切片的扩容机制进行了改进，扩容策略更加平滑，可以减少内存碎片。
Go 切片Slice的长度len与容量cap
大叶子不小的博客
06-16 1529
0x00 简介 Go 语言之旅示例 切片的长度与容量 切片拥有长度和容量。 切片的长度是它所包含的元素个数。 切片的容量是从它的第一个元素开始数，到其底层数组元素末尾的个数。 切片 s 的长度和容量可通过表达式 len(s) 和 cap(s) 来获取。 package main import "fmt" func main() { s := []int{2, 3, 5, 7, 11, 13} printSlice(s) // 截取切片使其长度为 0 s = s[:0...
Golang中的Slice与数组及区别详解
01-21
在golang中有数组和Slice两种数据结构，Slice是基于数组的实现，是长度动态不固定的数据结构，本质上是一个对数组字序列的引用，提供了对数组的轻量级访问。那么我们今天就给大家详细介绍下Golang中的Slice与数组， ...
Golang Map实现赋值和扩容的示例代码
09-16
在进行Map的赋值和扩容操作时，Golang会根据不同的情况选择不同的策略来优化性能。 1. **Map赋值操作**： 当我们对Map进行赋值操作，如`mapExample["hello"] = value`，Golang会调用相应的函数，如`mapassign`，...
Golang数组的传递详解
09-19
总的来说，理解Golang中的数组和切片以及它们在函数参数传递中的行为是编写高效代码的关键。在处理大数组时，应优先考虑使用切片或指针来避免不必要的性能开销。此外，掌握按值传递和按引用传递的概念有助于更好地...
Golang底层原理剖析之slice类型与扩容机制
清风
10-26 812
浅谈Golang slice类型与扩容机制slice类型扩容机制 slice类型 在runtime下的slice.go可以看到 type slice struct { array unsafe.Pointer len int cap int } slice基础结构包括保存数据的array、长度len与容量cap，其底层是数组array 这里的ints[3]和ints[4]不能访问，否则属于越界访问，会引发panic 扩容机制 在runtime下的slice.go内有一个扩容growslic
golang切片总结
xuemeilu的博客
06-13 293
golang切片总结，内存变化总结
关于Golang中数组append超容之后扩容的特性分析
weixin_44466331的博客
08-13 923
关于Golang中数组append超容之后扩容的特性分析 首先贴上官方文档，教程代码如下： package main import "fmt" func main() { var s []int printSlice(s) // 添加一个空切片 s = append(s, 0) printSlice(s) // 这个切片会按需增长 s = append(s, 1) printSlice(s) // 可以一次性添加多个元素 s = append(s, 2, 3, 4) prin
Golang从入门到精通（八）：Golang数组
xiangxianghehe的博客
12-12 5052
数组定义数组是具有相同唯一类型的一组已编号且长度固定的数据项序列（这是一种同构的数据结构）；这种类型可以是任意的原始类型例如整形、字符串或者自定义类型。数组长度必须是一个常量表达式，并且必须是一个非负整数。需要强调：数组长度也是数组类型的一部分。Go语言数组数组是Go语言编程中最常用的数据结构之一。顾名思义，数组就是指一系列同一类型数据的集合。数组中包含的每个数据被称为数组元素（ element），
Go学习笔记-Go语言数组array和切片slice
Anonymous
12-06 4398
##Go 语言中定义数组主要包括以下四种形式： var [] var = []{元素1, 元素2, …} var [] = […]{元素1, 元素2, …} var [] = […]{索引1: 元素1, 索引2: 元素2, …} 在数组定义完成之后，可以通过索引来操作数组中的元素： [] = = [] ***** func main() { var a [2]int
go 语言数组
why154285的博客
07-14 707
1.什么是数组     数组属于复合型数据类型，它是由相同类型的一组零个或多个元素组成的固定长度的集合。go语言中很少直接使用数组，一般使用slice（切片），切片的长度是可以扩展的，但是slice的底层还是使用的数组。数组提供了len()方法统计自己的长度。2.数组的声明和初始化    声明数组:    a.没有指定数组的大小var arrInt []int fmt.Printf("%T",ar...
Go语言中append()函数的扩容实验
流年入笔
05-24 3057
在学习Go语言数组的append()函数时遇到一个有趣的现象，当我使用如下代码测试扩容的时候： import "fmt" func main() { var numbers []int printSlice(numbers) numbers = append(numbers, 0) printSlice(numbers) numbers = append(n...
golang slice 详解
热门推荐
陈永坤
12-25 1万+
一.数组切片的使用: func main() { //1.基于数组创建数组切片 var array [10]int = [10]int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10} var slice = array[1:7] //array[startIndex:endIndex] 不包含endIndex //2.直接创建数组切片 slice2 := make([]i
Golang切片扩容机制
DYAN的博客
08-02 1710
前言 相信很多goher都知道slice在append时如果超出了原来的容量时会翻倍扩容。 疑问 这种翻倍扩容是可持续的吗？比如slice已经4GB了，这个时候难道会直接申请8GB？带着这个疑问我们直接去源码里找答案。 真相 // src/runtime/slice.go // go version 1.13 func growslice(et *_type, old slice, cap int) slice { // ...省略部分 newcap := old.cap doublecap
Golang教程：（十一）数组和切片
Cynhard的专栏
07-16 1万+
原文：https://golangbot.com/arrays-and-slices/ 这是本Golang系列教程的第十一篇。 数组 数组是属于同一类型的元素的集合。例如，整数 5, 8, 9, 79, 76 的集合就构成了一个数组。Go不允许在数组中混合使用不同类型的元素（比如整数和字符串）。 声明 数组的类型为 n[T]，其中 n 表示数组中元素的个数，T 表示数组中元素的类型。
golang的数组和切片
09-13
Golang的数组和切片是两种不同的数据类型，用于存储相同数据类型的容器。数组的长度是固定的，而切片的长度是可变的。在日常应用中，切片的使用更为普遍。 数组在声明时需要指定长度，并且在初始化时必须提供相同...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值