golang内幕之数组

最新推荐文章于 2022-02-25 14:29:31 发布
置顶 最新推荐文章于 2022-02-25 14:29:31 发布
阅读量236 收藏
点赞数
分类专栏： golang内幕 文章标签： golang go 数组 array
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/QQ1130141391/article/details/96762829
版权 
func Array_1() {
	var arr1 [3]int
	arr1[0] = 1
	arr1[1] = 2
	arr1[2] = 3
	fmt.Fprintf(os.Stdout, "%T - %v\n", arr1, arr1)

	arr2 := [3]int{
		1,
		2,
		3,
	}
	fmt.Fprintf(os.Stdout, "%T - %v\n", arr2, arr2)

	arr3 := [3]int {1,2,3}
	fmt.Fprintf(os.Stdout, "%T - %v\n", arr3, arr3)

	arr4 := [3]int {
		1,
		2,
		3}
	fmt.Fprintf(os.Stdout, "%T - %v\n", arr4, arr4)
}

数组定义如上，注意逗号的使用。

下面看看数组是如何分配内存的：

func Array_1() {
	arr2 := [3]int{
		1,
		2,
		3,
	}
	arr2[0] = 4
}
	0x0000 00000 (array.go:3)	TEXT	"".Array_1(SB), NOSPLIT|ABIInternal, $32-0
	0x0000 00000 (array.go:3)	SUBQ	$32, SP
	0x0004 00004 (array.go:3)	MOVQ	BP, 24(SP)
	0x0009 00009 (array.go:3)	LEAQ	24(SP), BP
    ...
	0x000e 00014 (array.go:4)	MOVQ	$0, "".arr2(SP)
	0x0016 00022 (array.go:4)	XORPS	X0, X0
	0x0019 00025 (array.go:4)	MOVUPS	X0, "".arr2+8(SP)
	0x001e 00030 (array.go:5)	MOVQ	$1, "".arr2(SP)
	0x0026 00038 (array.go:6)	MOVQ	$2, "".arr2+8(SP)
	0x002f 00047 (array.go:7)	MOVQ	$3, "".arr2+16(SP)
	0x0038 00056 (array.go:9)	MOVQ	$0, "".arr2(SP)
	0x0040 00064 (array.go:10)	MOVQ	24(SP), BP
	0x0045 00069 (array.go:10)	ADDQ	$32, SP
	0x0049 00073 (array.go:10)	RET

这里的array没涉及到动态分配内存，使用的只有栈空间，这个因为golang发现array只有在本函数内使用，不涉及传递。

func Array_1() {
	arr2 := [3]int{
		1,
		2,
		3,
	}
	Array_2(arr2)
}

func Array_2(arr [3]int) {
	fmt.Println(arr)
}
"".Array_1 STEXT size=128 args=0x0 locals=0x38
	0x0000 00000 (array.go:5)	TEXT	"".Array_1(SB), ABIInternal, $56-0
	0x0000 00000 (array.go:5)	MOVQ	TLS, CX
	0x0009 00009 (array.go:5)	MOVQ	(CX)(TLS*2), CX
	0x0010 00016 (array.go:5)	CMPQ	SP, 16(CX)
	0x0014 00020 (array.go:5)	JLS	121
	0x0016 00022 (array.go:5)	SUBQ	$56, SP
	0x001a 00026 (array.go:5)	MOVQ	BP, 48(SP)
	0x001f 00031 (array.go:5)	LEAQ	48(SP), BP
    ...
	0x0024 00036 (array.go:6)	PCDATA	$2, $0
	0x0024 00036 (array.go:6)	PCDATA	$0, $0
	0x0024 00036 (array.go:6)	MOVQ	$0, "".arr2+24(SP)
	0x002d 00045 (array.go:6)	XORPS	X0, X0
	0x0030 00048 (array.go:6)	MOVUPS	X0, "".arr2+32(SP)
	0x0035 00053 (array.go:7)	MOVQ	$1, "".arr2+24(SP)
	0x003e 00062 (array.go:8)	MOVQ	$2, "".arr2+32(SP)
	0x0047 00071 (array.go:9)	MOVQ	$3, "".arr2+40(SP)
	0x0050 00080 (array.go:11)	MOVQ	$1, (SP)
	0x0058 00088 (array.go:11)	MOVQ	$2, 8(SP)
	0x0061 00097 (array.go:11)	MOVQ	$3, 16(SP)
	0x006a 00106 (array.go:11)	CALL	"".Array_2(SB)
	0x006f 00111 (array.go:12)	MOVQ	48(SP), BP
	0x0074 00116 (array.go:12)	ADDQ	$56, SP
	0x0078 00120 (array.go:12)	RET

这会还没看到动态分配内存，但我么发现，调用Array_2也因此没有传递数组arr2的地址过去，而是把arr2的值传递过去了。

从这个例子可以看出，数组作为函数参数传递，是按照值传递方式传递的。

"".Array_2 STEXT size=273 args=0x18 locals=0x90
	0x0000 00000 (array.go:14)	TEXT	"".Array_2(SB), ABIInternal, $144-24
	0x0000 00000 (array.go:14)	MOVQ	TLS, CX
	0x0009 00009 (array.go:14)	MOVQ	(CX)(TLS*2), CX
	0x0010 00016 (array.go:14)	LEAQ	-16(SP), AX
	0x0015 00021 (array.go:14)	CMPQ	AX, 16(CX)
	0x0019 00025 (array.go:14)	JLS	263
	0x001f 00031 (array.go:14)	SUBQ	$144, SP
	0x0026 00038 (array.go:14)	MOVQ	BP, 136(SP)
	0x002e 00046 (array.go:14)	LEAQ	136(SP), BP
    ...
	0x0036 00054 (array.go:15)	MOVQ	"".arr+152(SP), AX
	0x003e 00062 (array.go:15)	MOVQ	AX, ""..autotmp_2+48(SP)
	0x0043 00067 (array.go:15)	MOVUPS	"".arr+160(SP), X0
	0x004b 00075 (array.go:15)	MOVUPS	X0, ""..autotmp_2+56(SP)
	0x0050 00080 (array.go:15)	PCDATA	$0, $1
	0x0050 00080 (array.go:15)	XORPS	X0, X0
	0x0053 00083 (array.go:15)	MOVUPS	X0, ""..autotmp_1+96(SP)
	0x0058 00088 (array.go:15)	PCDATA	$2, $1
	0x0058 00088 (array.go:15)	PCDATA	$0, $0
	0x0058 00088 (array.go:15)	LEAQ	""..autotmp_1+96(SP), AX
	0x005d 00093 (array.go:15)	PCDATA	$2, $0
	0x005d 00093 (array.go:15)	PCDATA	$0, $2
	0x005d 00093 (array.go:15)	MOVQ	AX, ""..autotmp_4+72(SP)
	0x0062 00098 (array.go:15)	PCDATA	$2, $1
	0x0062 00098 (array.go:15)	LEAQ	type.[3]int(SB), AX
	0x0069 00105 (array.go:15)	PCDATA	$2, $0
	0x0069 00105 (array.go:15)	MOVQ	AX, (SP)
	0x006d 00109 (array.go:15)	PCDATA	$2, $1
	0x006d 00109 (array.go:15)	LEAQ	""..autotmp_2+48(SP), AX
	0x0072 00114 (array.go:15)	PCDATA	$2, $0
	0x0072 00114 (array.go:15)	MOVQ	AX, 8(SP)
	0x0077 00119 (array.go:15)	CALL	runtime.convT2Enoptr(SB)
	0x007c 00124 (array.go:15)	MOVQ	16(SP), AX
	0x0081 00129 (array.go:15)	PCDATA	$2, $2
	0x0081 00129 (array.go:15)	MOVQ	24(SP), CX
	0x0086 00134 (array.go:15)	MOVQ	AX, ""..autotmp_5+80(SP)
	0x008b 00139 (array.go:15)	MOVQ	CX, ""..autotmp_5+88(SP)
	0x0090 00144 (array.go:15)	PCDATA	$2, $3
	0x0090 00144 (array.go:15)	MOVQ	""..autotmp_4+72(SP), DX
	0x0095 00149 (array.go:15)	TESTB	AL, (DX)
	0x0097 00151 (array.go:15)	MOVQ	AX, (DX)
	0x009a 00154 (array.go:15)	PCDATA	$2, $4
	0x009a 00154 (array.go:15)	LEAQ	8(DX), DI
	...
	0x009e 00158 (array.go:15)	CMPL	runtime.writeBarrier(SB), $0
	0x00a5 00165 (array.go:15)	JEQ	169
	0x00a7 00167 (array.go:15)	JMP	253
	0x00a9 00169 (array.go:15)	MOVQ	CX, 8(DX)
	0x00ad 00173 (array.go:15)	JMP	175
	0x00af 00175 (array.go:15)	PCDATA	$2, $1
	0x00af 00175 (array.go:15)	PCDATA	$0, $0
	0x00af 00175 (array.go:15)	MOVQ	""..autotmp_4+72(SP), AX
	0x00b4 00180 (array.go:15)	TESTB	AL, (AX)
	0x00b6 00182 (array.go:15)	JMP	184
	0x00b8 00184 (array.go:15)	MOVQ	AX, ""..autotmp_3+112(SP)
	0x00bd 00189 (array.go:15)	MOVQ	$1, ""..autotmp_3+120(SP)
	0x00c6 00198 (array.go:15)	MOVQ	$1, ""..autotmp_3+128(SP)
	0x00d2 00210 (array.go:15)	PCDATA	$2, $0
	0x00d2 00210 (array.go:15)	MOVQ	AX, (SP)
	0x00d6 00214 (array.go:15)	MOVQ	$1, 8(SP)
	0x00df 00223 (array.go:15)	MOVQ	$1, 16(SP)
	0x00e8 00232 (array.go:15)	CALL	fmt.Println(SB)
	0x00ed 00237 (array.go:16)	MOVQ	136(SP), BP
	0x00f5 00245 (array.go:16)	ADDQ	$144, SP
	0x00fc 00252 (array.go:16)	RET
LEAQ    type.[3]int(SB), AX
runtime.convT2Enoptr(SB)
func convT2Enoptr(t *_type, elem unsafe.Pointer) (e eface) {
    ...
	x := mallocgc(t.size, t, false)
	memmove(x, elem, t.size)
	e._type = t
	e.data = x
	return
}

这里我们终于看到涉及到动态内存分配了，也可以看到动态分配内存的array的底层数据结构是eface。

我们写段代码验证一下数组是值传递的：

func Array_1() {
	arr2 := [3]int{
		1,
		2,
		3,
	}
	fmt.Println(arr2)
	Array_2(arr2)
	fmt.Println(arr2)
}

func Array_2(arr [3]int) {
	arr[0] =  4
	arr[1] =  5
	arr[2] =  6
}
=== RUN   TestArray_1
[1 2 3]
[1 2 3]
--- PASS: TestArray_1 (0.00s)
PASS

确实，在Array_2中改变Array_1传入的数组的值，但其实没改，说明数组是值传递。

如果我们确实想修改arr2的值呢？

func Array_1() {
	arr2 := [3]int{
		1,
		2,
		3,
	}
	fmt.Println(arr2)
	Array_2(&arr2)
	fmt.Println(arr2)
}

func Array_2(arr *[3]int) {
	arr[0] =  4
	arr[1] =  5
	arr[2] =  6
}
=== RUN   TestArray_1
[1 2 3]
[4 5 6]
--- PASS: TestArray_1 (0.00s)
PASS

按照指针传递，果然修改成功了。

再看看len, cap：

func Array_1() {
	arr2 := [3]int{
		1,
		2,
		3,
	}
	fmt.Println(arr2, len(arr2), cap(arr2))
}
=== RUN   TestArray_1
[1 2 3] 3 3
--- PASS: TestArray_1 (0.00s)
PASS

数组是编译期间就确定大小的，因此cap和len都是编译时的固定值。

 

 

mq30
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Golang数据结构-队列(数组)
qq_43498850的博客
03-30 658
文章目录一、Golang数据结构-队列(数组)1.基本介绍2.处理方法数组模拟队列二、使用步骤1.使用一个结构体管理队列2.添加队列数据3.显示队列，找到队首，然后遍历到队尾4.从队列中取出数据5.编写一个主函数测试三、运行结果总结 一、Golang数据结构-队列(数组) 1.基本介绍 （1）队列是一个有序列表，可以用数组或者是链表来实现。 （2）遵循先入先出原则。即：先存入队列的数据，要先取出。后存入的要后取出 2.处理方法 数组模拟队列 （1）队列本身是有序列表，若使用数组的结构来存储队列的数据..
golang interface 与 反射
惜暮
02-01 2840
golang interface 与 反射golang interface 使用场景golang interface 数据结构golang interface 一些使用场景原理函数参数是 interface 的成本interface{}和带方法的interface的赋值过程动态类型与动态分发是如何实现的，动态分发什么时候进行，并且有什么样的调用成本如何进行类型转换如何进行断言，断言的成本有多高为什...
对GoLang里的slice要谨慎使用append操作
编程交流
04-12 1万+
package main import ( "fmt" ) func main() { array := []int{10, 11, 12, 13, 14} slice := array[0:5] fmt.Println("array: ", array) fmt.Println("slice: ", slice) array[0] += 10 slic
【LeetCode】977. 有序数组的平方（Java）
小楊同学的笔记本
10-07 344
给定一个按非递减顺序排序的整数数组 A，返回每个数字的平方组成的新数组，要求也按非递减顺序排序。 解法一 遍历排序 class Solution { public int[] sortedSquares(int[] A) { //遍历平方 for (int i = 0; i < A.length; i++) { A[i] *= A[i]; } //排序 Arrays.sort(A);
【go源码分析】go源码之interface源码分析
zhonglinzhang
01-04 4161
interface实现原理 类似于C++多态的实现，存在两种interface，一种是带有方法的interface实现（iface struct），一种是不带方法的interface实现（eface struct）， iface结构体 tab：类似于C++的vptr，tab中包含了对应的方法数组，包含实现该接口的类型元数据 data：实现该接口的类型的实例指针 ...
go代码-golang一维数组
07-14
在Go语言中，一维数组是一种基础的数据结构，它存储同一类型的数据集合。本文将深入探讨Go语言中一维数组的定义、初始化、操作以及与其他数据结构的转换。我们将通过分析`main.go`中的示例代码来理解这些概念，并...
Golang算法问题之数组按指定规则排序的方法分析
09-21
主要介绍了Golang算法问题之数组按指定规则排序的方法,结合实例形式分析了Go语言数组排序相关算法原理与操作技巧,需要的朋友可以参考下
go代码-golang二维数组IO
07-16
在Golang中，二维数组是一种常见的数据结构，用于表示矩阵或类似表格的数据。它是由一个或多个一维数组组成的数组，每个一维数组可以有不同的长度，但通常在实践中，我们保持所有子数组长度一致，以形成一个规整的...
golang数组
低调的骏马
11-07 896
golang数组 定义数组 var n [10]int /* n 是一个长度为 10 的数组 */ 快速初始化 package main import "fmt" func main() { var i,j,k int // 声明数组的同时快速初始化数组 balance := [5]float32{1000.0, 2.0, 3.4, 7.0, 50.0} /* 输出数组元素 */ for i = 0; i < 5; i++ { fmt.Printf("
golang append数组
热门推荐
wwqcherry的博客
07-05 1万+
golang切片append一个数组：list = append(append, anotherList...) mylist := make([]int, 0, 10) mylist1 := []int{1, 2, 3} mylist = append(mylist, mylist1...) //加上'...'就可以追加一个数组， 否则只能追加一个元素 fmt.Print(mylist) fmt.Println(len(mylist)) fmt.Println(cap(mylist)) 输出： [1
08-go数据类型内存结构-interface
浩玥当空
06-23 827
1. 值接收者和指针接收者 实现了接收者是值类型的方法， 自动生成了接收者是指针类型的方法； 实现了接收者是指针类型的方法，不会自动生成对应接收者是值类型的方法。 2. iface 与 eface 都是两个成员，第二个成员都是接口存放的数据。不同的是第一个成员。 eface._type接口保存的实体类型，没有包含任何接口方法。 iface.tab是一个itab结构，itab.inter是一个i...
Golang 基于数组、链表实现队列
baobaoxiannv的博客
02-25 205
使用数组、队列实现简单的队列能力 Top() 返回队列第一个元素 Add() 入队 Remove(data int) 出队 package main func main() { lq := NewListQueue() lq.Add(10) lq.Add(20) lq.Add(25) lq.Add(30) lq.Add(100) lq.Remove() lq.Remove() lq.Remove() lq.Remove() fmt.Println(lq.size) lq.Ad
Golang 汇编入门知识总结
腾讯技术工程
09-04 2361
作者：ivansli，腾讯 IEG 运营开发工程师在深入学习 Golang 的 runtime 和标准库实现的时候发现，如果对 Golang 汇编没有一定了解的话，很难深入了解其底层实现...
golang slice往中部添加元素的三种方式
weixin_38707040的博客
09-01 1万+
场景如下，有一个切片：a = []int{1,2,4,5,6}，想在中部添加一个元素，使得a = []int{1,2,4,5,6}，有三种方式 1.创建临时切片 var a = []int{1,2,4,5,6} var b= a[2:] b = append([]int{3},b[0:]...) a=append(a[0:2],b...) 2.利用append支持链式操作的特性 var...
golang内幕之协程状态切换
QQ1130141391的专栏
07-18 2646
本文承接上一篇文章【golang内幕之程序启动流程】【https://blog.csdn.net/QQ1130141391/article/details/96197570】 在【golang内幕之程序启动流程】文中我们提到了在主线程中启动了main Goroutine，并提到了schedule是一轮的协程调度，并且是永不返回的，这正是我们研究的入口点；另外也提到了go func(){}...
golang内幕之程序启动流程
QQ1130141391的专栏
07-17 1739
文件：startup.go ，代码如下： package main import "fmt" func main() { fmt.Println("startup") } 上面是golang程序的入口函数，即main包中的main函数。但main.main并发golang真正的程序入口，golang存在一个运行时（runtime），与我们的编写的golang代码一起编译、链接成可执行...
golang内幕之for-go-statement
QQ1130141391的专栏
07-20 395
func ForGoStatement_1() { go func() { fmt.Println("go-func-1") }() } func main() { ForGoStatement_1() } 参考如下文章，会更清楚golang的协程： 【golang内幕之程序启动流程】【https://blog.csdn.net/QQ1130141391/article/deta...
golang内幕之组合
QQ1130141391的专栏
07-20 324
type Parent struct { Name string Age int } func (p Parent) String() string { return fmt.Sprintf("Name:%s, Age:%d", p.Name, p.Age) } func StructCombine_1() { var p1 = Parent{} fmt.Println(p1) ...
golang内幕之defer-panic-recover
QQ1130141391的专栏
07-20 274
问题：defer适用在什么场景？ 我们先看下下面一段拷贝文件的代码： func CopyFile_1(src, dst string) (wlen int64, err error) { sfd, err := os.Open(src) if err != nil { return 0, err } dfd, err := os.Create(dst) if err != n...
golang切片和数组的区别
最新发布
07-27
回答: 在Golang中，数组和切片有以下几个区别。首先，数组的长度是固定的，而切片的长度是可变的。其次，数组是值类型，而切片是引用类型。这意味着当数组被赋值给另一个变量时，会创建一个新的数组副本，而切片则是...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值