Go语言中append()函数的扩容实验

最新推荐文章于 2024-04-22 00:14:58 发布
最新推荐文章于 2024-04-22 00:14:58 发布
阅读量3k 收藏 1
点赞数
分类专栏： 学习笔记 文章标签： Go append() 扩容机制
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_29102545/article/details/90512502
版权

在学习Go语言数组的append()函数时遇到一个有趣的现象，当我使用如下代码测试扩容的时候：

import "fmt"

func main() {
   var numbers []int
   printSlice(numbers)

   numbers = append(numbers, 0)
   printSlice(numbers)

   numbers = append(numbers, 1)
   printSlice(numbers)

   numbers = append(numbers, 2)
   printSlice(numbers)

   numbers = append(numbers, 3)
   printSlice(numbers)

   numbers = append(numbers, 4)
   printSlice(numbers)

   numbers = append(numbers, 5, 6, 7)
   printSlice(numbers)

   numbers = append(numbers, 8)
   printSlice(numbers)

   numbers = append(numbers, 9, 10, 11)
   printSlice(numbers)
}

func printSlice(x []int){
   fmt.Printf("len=%d cap=%d slice=%v\n",len(x),cap(x),x)
}

输出如下：

可以看到容量是以2倍的速率增长的，但是换一种测试方式：

package main

import "fmt"

func main() {
   var numbers []int
   printSlice(numbers)

   numbers = append(numbers, 0)
   printSlice(numbers)

   numbers = append(numbers, 1, 2, 3, 4)
   printSlice(numbers)

   numbers = append(numbers, 5)
   printSlice(numbers)

   numbers = append(numbers, 6)
   printSlice(numbers)
}

func printSlice(x []int){
   fmt.Printf("len=%d cap=%d slice=%v\n",len(x),cap(x),x)
}

输入如下：

结局似乎和预想的不太一样，第一次添加一个元素，扩容到了长度和容量都为1的情况，第二次一次性添加了四个元素，当按照二倍增长来推算的话首先cap要增长到2，发现不够后继续增长2倍到4，发现还是不够，继续增长到8，所以当我一次性添加四个元素的时候，本应该输出len=5 cap=8 slice=[0 1 2 3 4]，但实际输出的cap是6，由此可知：

在Go语言中，通过append()函数向slice中添加元素，按照二倍增长后capacity依然不够用时，会将capacity设置为当前数组的length+1.

更正！！！

更新了实验，我有点摸不透了兄弟们...（向初始cap为0的空slice中一次性添加1个、2个、...、300个的实验代码和结果如下，大概看了一下扩容后cap的计算结果，还是有些规律的，不过具体的算法懒得梳理了，有感兴趣的大佬可以告知一下）

package main

import "fmt"

func printSliceBefore(x []int) {
	fmt.Printf("init len[%d] cap[%d] -> ", len(x), cap(x))
}

func printSliceAfter(x []int) {
	fmt.Printf("After append: len[%d] cap[%d]\n", len(x), cap(x))
}

func main() {
	for i := 1; i <= 300; i++ {
		var numbers = make([]int, 0)
		printSliceBefore(numbers)
		numbers = append(numbers, make([]int, i)...)
		printSliceAfter(numbers)
	}
}

=======================================================
[Running] go run "c:\Users\Hyleon\hello\hello.go"
init len[0] cap[0] -> After append: len[1] cap[1]
init len[0] cap[0] -> After append: len[2] cap[2]
init len[0] cap[0] -> After append: len[3] cap[3]
init len[0] cap[0] -> After append: len[4] cap[4]
init len[0] cap[0] -> After append: len[5] cap[6]
init len[0] cap[0] -> After append: len[6] cap[6]
init len[0] cap[0] -> After append: len[7] cap[8]
init len[0] cap[0] -> After append: len[8] cap[8]
init len[0] cap[0] -> After append: len[9] cap[10]
init len[0] cap[0] -> After append: len[10] cap[10]
init len[0] cap[0] -> After append: len[11] cap[12]
init len[0] cap[0] -> After append: len[12] cap[12]
init len[0] cap[0] -> After append: len[13] cap[14]
init len[0] cap[0] -> After append: len[14] cap[14]
init len[0] cap[0] -> After append: len[15] cap[16]
init len[0] cap[0] -> After append: len[16] cap[16]
init len[0] cap[0] -> After append: len[17] cap[18]
init len[0] cap[0] -> After append: len[18] cap[18]
init len[0] cap[0] -> After append: len[19] cap[20]
init len[0] cap[0] -> After append: len[20] cap[20]
init len[0] cap[0] -> After append: len[21] cap[22]
init len[0] cap[0] -> After append: len[22] cap[22]
init len[0] cap[0] -> After append: len[23] cap[24]
init len[0] cap[0] -> After append: len[24] cap[24]
init len[0] cap[0] -> After append: len[25] cap[26]
init len[0] cap[0] -> After append: len[26] cap[26]
init len[0] cap[0] -> After append: len[27] cap[28]
init len[0] cap[0] -> After append: len[28] cap[28]
init len[0] cap[0] -> After append: len[29] cap[30]
init len[0] cap[0] -> After append: len[30] cap[30]
init len[0] cap[0] -> After append: len[31] cap[32]
init len[0] cap[0] -> After append: len[32] cap[32]
init len[0] cap[0] -> After append: len[33] cap[36]
init len[0] cap[0] -> After append: len[34] cap[36]
init len[0] cap[0] -> After append: len[35] cap[36]
init len[0] cap[0] -> After append: len[36] cap[36]
init len[0] cap[0] -> After append: len[37] cap[40]
init len[0] cap[0] -> After append: len[38] cap[40]
init len[0] cap[0] -> After append: len[39] cap[40]
init len[0] cap[0] -> After append: len[40] cap[40]
init len[0] cap[0] -> After append: len[41] cap[44]
init len[0] cap[0] -> After append: len[42] cap[44]
init len[0] cap[0] -> After append: len[43] cap[44]
init len[0] cap[0] -> After append: len[44] cap[44]
init len[0] cap[0] -> After append: len[45] cap[48]
init len[0] cap[0] -> After append: len[46] cap[48]
init len[0] cap[0] -> After append: len[47] cap[48]
init len[0] cap[0] -> After append: len[48] cap[48]
init len[0] cap[0] -> After append: len[49] cap[52]
init len[0] cap[0] -> After append: len[50] cap[52]
init len[0] cap[0] -> After append: len[51] cap[52]
init len[0] cap[0] -> After append: len[52] cap[52]
init len[0] cap[0] -> After append: len[53] cap[56]
init len[0] cap[0] -> After append: len[54] cap[56]
init len[0] cap[0] -> After append: len[55] cap[56]
init len[0] cap[0] -> After append: len[56] cap[56]
init len[0] cap[0] -> After append: len[57] cap[60]
init len[0] cap[0] -> After append: len[58] cap[60]
init len[0] cap[0] -> After append: len[59] cap[60]
init len[0] cap[0] -> After append: len[60] cap[60]
init len[0] cap[0] -> After append: len[61] cap[64]
init len[0] cap[0] -> After append: len[62] cap[64]
init len[0] cap[0] -> After append: len[63] cap[64]
init len[0] cap[0] -> After append: len[64] cap[64]
init len[0] cap[0] -> After append: len[65] cap[72]
init len[0] cap[0] -> After append: len[66] cap[72]
init len[0] cap[0] -> After append: len[67] cap[72]
init len[0] cap[0] -> After append: len[68] cap[72]
init len[0] cap[0] -> After append: len[69] cap[72]
init len[0] cap[0] -> After append: len[70] cap[72]
init len[0] cap[0] -> After append: len[71] cap[72]
init len[0] cap[0] -> After append: len[72] cap[72]
init len[0] cap[0] -> After append: len[73] cap[80]
init len[0] cap[0] -> After append: len[74] cap[80]
init len[0] cap[0] -> After append: len[75] cap[80]
init len[0] cap[0] -> After append: len[76] cap[80]
init len[0] cap[0] -> After append: len[77] cap[80]
init len[0] cap[0] -> After append: len[78] cap[80]
init len[0] cap[0] -> After append: len[79] cap[80]
init len[0] cap[0] -> After append: len[80] cap[80]
init len[0] cap[0] -> After append: len[81] cap[88]
init len[0] cap[0] -> After append: len[82] cap[88]
init len[0] cap[0] -> After append: len[83] cap[88]
init len[0] cap[0] -> After append: len[84] cap[88]
init len[0] cap[0] -> After append: len[85] cap[88]
init len[0] cap[0] -> After append: len[86] cap[88]
init len[0] cap[0] -> After append: len[87] cap[88]
init len[0] cap[0] -> After append: len[88] cap[88]
init len[0] cap[0] -> After append: len[89] cap[96]
init len[0] cap[0] -> After append: len[90] cap[96]
init len[0] cap[0] -> After append: len[91] cap[96]
init len[0] cap[0] -> After append: len[92] cap[96]
init len[0] cap[0] -> After append: len[93] cap[96]
init len[0] cap[0] -> After append: len[94] cap[96]
init len[0] cap[0] -> After append: len[95] cap[96]
init len[0] cap[0] -> After append: len[96] cap[96]
init len[0] cap[0] -> After append: len[97] cap[112]
init len[0] cap[0] -> After append: len[98] cap[112]
init len[0] cap[0] -> After append: len[99] cap[112]
init len[0] cap[0] -> After append: len[100] cap[112]
init len[0] cap[0] -> After append: len[101] cap[112]
init len[0] cap[0] -> After append: len[102] cap[112]
init len[0] cap[0] -> After append: len[103] cap[112]
init len[0] cap[0] -> After append: len[104] cap[112]
init len[0] cap[0] -> After append: len[105] cap[112]
init len[0] cap[0] -> After append: len[106] cap[112]
init len[0] cap[0] -> After append: len[107] cap[112]
init len[0] cap[0] -> After append: len[108] cap[112]
init len[0] cap[0] -> After append: len[109] cap[112]
init len[0] cap[0] -> After append: len[110] cap[112]
init len[0] cap[0] -> After append: len[111] cap[112]
init len[0] cap[0] -> After append: len[112] cap[112]
init len[0] cap[0] -> After append: len[113] cap[128]
init len[0] cap[0] -> After append: len[114] cap[128]
init len[0] cap[0] -> After append: len[115] cap[128]
init len[0] cap[0] -> After append: len[116] cap[128]
init len[0] cap[0] -> After append: len[117] cap[128]
init len[0] cap[0] -> After append: len[118] cap[128]
init len[0] cap[0] -> After append: len[119] cap[128]
init len[0] cap[0] -> After append: len[120] cap[128]
init len[0] cap[0] -> After append: len[121] cap[128]
init len[0] cap[0] -> After append: len[122] cap[128]
init len[0] cap[0] -> After append: len[123] cap[128]
init len[0] cap[0] -> After append: len[124] cap[128]
init len[0] cap[0] -> After append: len[125] cap[128]
init len[0] cap[0] -> After append: len[126] cap[128]
init len[0] cap[0] -> After append: len[127] cap[128]
init len[0] cap[0] -> After append: len[128] cap[128]
init len[0] cap[0] -> After append: len[129] cap[144]
init len[0] cap[0] -> After append: len[130] cap[144]
init len[0] cap[0] -> After append: len[131] cap[144]
init len[0] cap[0] -> After append: len[132] cap[144]
init len[0] cap[0] -> After append: len[133] cap[144]
init len[0] cap[0] -> After append: len[134] cap[144]
init len[0] cap[0] -> After append: len[135] cap[144]
init len[0] cap[0] -> After append: len[136] cap[144]
init len[0] cap[0] -> After append: len[137] cap[144]
init len[0] cap[0] -> After append: len[138] cap[144]
init len[0] cap[0] -> After append: len[139] cap[144]
init len[0] cap[0] -> After append: len[140] cap[144]
init len[0] cap[0] -> After append: len[141] cap[144]
init len[0] cap[0] -> After append: len[142] cap[144]
init len[0] cap[0] -> After append: len[143] cap[144]
init len[0] cap[0] -> After append: len[144] cap[144]
init len[0] cap[0] -> After append: len[145] cap[160]
init len[0] cap[0] -> After append: len[146] cap[160]
init len[0] cap[0] -> After append: len[147] cap[160]
init len[0] cap[0] -> After append: len[148] cap[160]
init len[0] cap[0] -> After append: len[149] cap[160]
init len[0] cap[0] -> After append: len[150] cap[160]
init len[0] cap[0] -> After append: len[151] cap[160]
init len[0] cap[0] -> After append: len[152] cap[160]
init len[0] cap[0] -> After append: len[153] cap[160]
init len[0] cap[0] -> After append: len[154] cap[160]
init len[0] cap[0] -> After append: len[155] cap[160]
init len[0] cap[0] -> After append: len[156] cap[160]
init len[0] cap[0] -> After append: len[157] cap[160]
init len[0] cap[0] -> After append: len[158] cap[160]
init len[0] cap[0] -> After append: len[159] cap[160]
init len[0] cap[0] -> After append: len[160] cap[160]
init len[0] cap[0] -> After append: len[161] cap[176]
init len[0] cap[0] -> After append: len[162] cap[176]
init len[0] cap[0] -> After append: len[163] cap[176]
init len[0] cap[0] -> After append: len[164] cap[176]
init len[0] cap[0] -> After append: len[165] cap[176]
init len[0] cap[0] -> After append: len[166] cap[176]
init len[0] cap[0] -> After append: len[167] cap[176]
init len[0] cap[0] -> After append: len[168] cap[176]
init len[0] cap[0] -> After append: len[169] cap[176]
init len[0] cap[0] -> After append: len[170] cap[176]
init len[0] cap[0] -> After append: len[171] cap[176]
init len[0] cap[0] -> After append: len[172] cap[176]
init len[0] cap[0] -> After append: len[173] cap[176]
init len[0] cap[0] -> After append: len[174] cap[176]
init len[0] cap[0] -> After append: len[175] cap[176]
init len[0] cap[0] -> After append: len[176] cap[176]
init len[0] cap[0] -> After append: len[177] cap[192]
init len[0] cap[0] -> After append: len[178] cap[192]
init len[0] cap[0] -> After append: len[179] cap[192]
init len[0] cap[0] -> After append: len[180] cap[192]
init len[0] cap[0] -> After append: len[181] cap[192]
init len[0] cap[0] -> After append: len[182] cap[192]
init len[0] cap[0] -> After append: len[183] cap[192]
init len[0] cap[0] -> After append: len[184] cap[192]
init len[0] cap[0] -> After append: len[185] cap[192]
init len[0] cap[0] -> After append: len[186] cap[192]
init len[0] cap[0] -> After append: len[187] cap[192]
init len[0] cap[0] -> After append: len[188] cap[192]
init len[0] cap[0] -> After append: len[189] cap[192]
init len[0] cap[0] -> After append: len[190] cap[192]
init len[0] cap[0] -> After append: len[191] cap[192]
init len[0] cap[0] -> After append: len[192] cap[192]
init len[0] cap[0] -> After append: len[193] cap[224]
init len[0] cap[0] -> After append: len[194] cap[224]
init len[0] cap[0] -> After append: len[195] cap[224]
init len[0] cap[0] -> After append: len[196] cap[224]
init len[0] cap[0] -> After append: len[197] cap[224]
init len[0] cap[0] -> After append: len[198] cap[224]
init len[0] cap[0] -> After append: len[199] cap[224]
init len[0] cap[0] -> After append: len[200] cap[224]
init len[0] cap[0] -> After append: len[201] cap[224]
init len[0] cap[0] -> After append: len[202] cap[224]
init len[0] cap[0] -> After append: len[203] cap[224]
init len[0] cap[0] -> After append: len[204] cap[224]
init len[0] cap[0] -> After append: len[205] cap[224]
init len[0] cap[0] -> After append: len[206] cap[224]
init len[0] cap[0] -> After append: len[207] cap[224]
init len[0] cap[0] -> After append: len[208] cap[224]
init len[0] cap[0] -> After append: len[209] cap[224]
init len[0] cap[0] -> After append: len[210] cap[224]
init len[0] cap[0] -> After append: len[211] cap[224]
init len[0] cap[0] -> After append: len[212] cap[224]
init len[0] cap[0] -> After append: len[213] cap[224]
init len[0] cap[0] -> After append: len[214] cap[224]
init len[0] cap[0] -> After append: len[215] cap[224]
init len[0] cap[0] -> After append: len[216] cap[224]
init len[0] cap[0] -> After append: len[217] cap[224]
init len[0] cap[0] -> After append: len[218] cap[224]
init len[0] cap[0] -> After append: len[219] cap[224]
init len[0] cap[0] -> After append: len[220] cap[224]
init len[0] cap[0] -> After append: len[221] cap[224]
init len[0] cap[0] -> After append: len[222] cap[224]
init len[0] cap[0] -> After append: len[223] cap[224]
init len[0] cap[0] -> After append: len[224] cap[224]
init len[0] cap[0] -> After append: len[225] cap[256]
init len[0] cap[0] -> After append: len[226] cap[256]
init len[0] cap[0] -> After append: len[227] cap[256]
init len[0] cap[0] -> After append: len[228] cap[256]
init len[0] cap[0] -> After append: len[229] cap[256]
init len[0] cap[0] -> After append: len[230] cap[256]
init len[0] cap[0] -> After append: len[231] cap[256]
init len[0] cap[0] -> After append: len[232] cap[256]
init len[0] cap[0] -> After append: len[233] cap[256]
init len[0] cap[0] -> After append: len[234] cap[256]
init len[0] cap[0] -> After append: len[235] cap[256]
init len[0] cap[0] -> After append: len[236] cap[256]
init len[0] cap[0] -> After append: len[237] cap[256]
init len[0] cap[0] -> After append: len[238] cap[256]
init len[0] cap[0] -> After append: len[239] cap[256]
init len[0] cap[0] -> After append: len[240] cap[256]
init len[0] cap[0] -> After append: len[241] cap[256]
init len[0] cap[0] -> After append: len[242] cap[256]
init len[0] cap[0] -> After append: len[243] cap[256]
init len[0] cap[0] -> After append: len[244] cap[256]
init len[0] cap[0] -> After append: len[245] cap[256]
init len[0] cap[0] -> After append: len[246] cap[256]
init len[0] cap[0] -> After append: len[247] cap[256]
init len[0] cap[0] -> After append: len[248] cap[256]
init len[0] cap[0] -> After append: len[249] cap[256]
init len[0] cap[0] -> After append: len[250] cap[256]
init len[0] cap[0] -> After append: len[251] cap[256]
init len[0] cap[0] -> After append: len[252] cap[256]
init len[0] cap[0] -> After append: len[253] cap[256]
init len[0] cap[0] -> After append: len[254] cap[256]
init len[0] cap[0] -> After append: len[255] cap[256]
init len[0] cap[0] -> After append: len[256] cap[256]
init len[0] cap[0] -> After append: len[257] cap[288]
init len[0] cap[0] -> After append: len[258] cap[288]
init len[0] cap[0] -> After append: len[259] cap[288]
init len[0] cap[0] -> After append: len[260] cap[288]
init len[0] cap[0] -> After append: len[261] cap[288]
init len[0] cap[0] -> After append: len[262] cap[288]
init len[0] cap[0] -> After append: len[263] cap[288]
init len[0] cap[0] -> After append: len[264] cap[288]
init len[0] cap[0] -> After append: len[265] cap[288]
init len[0] cap[0] -> After append: len[266] cap[288]
init len[0] cap[0] -> After append: len[267] cap[288]
init len[0] cap[0] -> After append: len[268] cap[288]
init len[0] cap[0] -> After append: len[269] cap[288]
init len[0] cap[0] -> After append: len[270] cap[288]
init len[0] cap[0] -> After append: len[271] cap[288]
init len[0] cap[0] -> After append: len[272] cap[288]
init len[0] cap[0] -> After append: len[273] cap[288]
init len[0] cap[0] -> After append: len[274] cap[288]
init len[0] cap[0] -> After append: len[275] cap[288]
init len[0] cap[0] -> After append: len[276] cap[288]
init len[0] cap[0] -> After append: len[277] cap[288]
init len[0] cap[0] -> After append: len[278] cap[288]
init len[0] cap[0] -> After append: len[279] cap[288]
init len[0] cap[0] -> After append: len[280] cap[288]
init len[0] cap[0] -> After append: len[281] cap[288]
init len[0] cap[0] -> After append: len[282] cap[288]
init len[0] cap[0] -> After append: len[283] cap[288]
init len[0] cap[0] -> After append: len[284] cap[288]
init len[0] cap[0] -> After append: len[285] cap[288]
init len[0] cap[0] -> After append: len[286] cap[288]
init len[0] cap[0] -> After append: len[287] cap[288]
init len[0] cap[0] -> After append: len[288] cap[288]
init len[0] cap[0] -> After append: len[289] cap[336]
init len[0] cap[0] -> After append: len[290] cap[336]
init len[0] cap[0] -> After append: len[291] cap[336]
init len[0] cap[0] -> After append: len[292] cap[336]
init len[0] cap[0] -> After append: len[293] cap[336]
init len[0] cap[0] -> After append: len[294] cap[336]
init len[0] cap[0] -> After append: len[295] cap[336]
init len[0] cap[0] -> After append: len[296] cap[336]
init len[0] cap[0] -> After append: len[297] cap[336]
init len[0] cap[0] -> After append: len[298] cap[336]
init len[0] cap[0] -> After append: len[299] cap[336]
init len[0] cap[0] -> After append: len[300] cap[336]

[Done] exited with code=0 in 0.655 seconds

如果设定初始cap为10，实验结果在开始时略微不同，后面的变化规律与前面的实验一致，所以仅设置循环40次

package main

import "fmt"

func printSliceBefore(x []int) {
	fmt.Printf("init len[%d] cap[%d] -> ", len(x), cap(x))
}

func printSliceAfter(x []int) {
	fmt.Printf("After append: len[%d] cap[%d]\n", len(x), cap(x))
}

func main() {
	for i := 1; i <= 40; i++ {
		var numbers = make([]int, 0, 10)
		printSliceBefore(numbers)
		numbers = append(numbers, make([]int, i)...)
		printSliceAfter(numbers)
	}
}

==========================================================
[Running] go run "c:\Users\Hyleon\hello\hello.go"
init len[0] cap[10] -> After append: len[1] cap[10]
init len[0] cap[10] -> After append: len[2] cap[10]
init len[0] cap[10] -> After append: len[3] cap[10]
init len[0] cap[10] -> After append: len[4] cap[10]
init len[0] cap[10] -> After append: len[5] cap[10]
init len[0] cap[10] -> After append: len[6] cap[10]
init len[0] cap[10] -> After append: len[7] cap[10]
init len[0] cap[10] -> After append: len[8] cap[10]
init len[0] cap[10] -> After append: len[9] cap[10]
init len[0] cap[10] -> After append: len[10] cap[10]
init len[0] cap[10] -> After append: len[11] cap[20]
init len[0] cap[10] -> After append: len[12] cap[20]
init len[0] cap[10] -> After append: len[13] cap[20]
init len[0] cap[10] -> After append: len[14] cap[20]
init len[0] cap[10] -> After append: len[15] cap[20]
init len[0] cap[10] -> After append: len[16] cap[20]
init len[0] cap[10] -> After append: len[17] cap[20]
init len[0] cap[10] -> After append: len[18] cap[20]
init len[0] cap[10] -> After append: len[19] cap[20]
init len[0] cap[10] -> After append: len[20] cap[20]
init len[0] cap[10] -> After append: len[21] cap[22]
init len[0] cap[10] -> After append: len[22] cap[22]
init len[0] cap[10] -> After append: len[23] cap[24]
init len[0] cap[10] -> After append: len[24] cap[24]
init len[0] cap[10] -> After append: len[25] cap[26]
init len[0] cap[10] -> After append: len[26] cap[26]
init len[0] cap[10] -> After append: len[27] cap[28]
init len[0] cap[10] -> After append: len[28] cap[28]
init len[0] cap[10] -> After append: len[29] cap[30]
init len[0] cap[10] -> After append: len[30] cap[30]
init len[0] cap[10] -> After append: len[31] cap[32]
init len[0] cap[10] -> After append: len[32] cap[32]
init len[0] cap[10] -> After append: len[33] cap[36]
init len[0] cap[10] -> After append: len[34] cap[36]
init len[0] cap[10] -> After append: len[35] cap[36]
init len[0] cap[10] -> After append: len[36] cap[36]
init len[0] cap[10] -> After append: len[37] cap[40]
init len[0] cap[10] -> After append: len[38] cap[40]
init len[0] cap[10] -> After append: len[39] cap[40]
init len[0] cap[10] -> After append: len[40] cap[40]

[Done] exited with code=0 in 0.644 seconds

扩容算法代码如下：

// growslice handles slice growth during append.
// It is passed the slice element type, the old slice, and the desired new minimum capacity,
// and it returns a new slice with at least that capacity, with the old data
// copied into it.
// The new slice's length is set to the old slice's length,
// NOT to the new requested capacity.
// This is for codegen convenience. The old slice's length is used immediately
// to calculate where to write new values during an append.
// TODO: When the old backend is gone, reconsider this decision.
// The SSA backend might prefer the new length or to return only ptr/cap and save stack space.
func growslice(et *_type, old slice, cap int) slice {
	if raceenabled {
		callerpc := getcallerpc()
		racereadrangepc(old.array, uintptr(old.len*int(et.size)), callerpc, funcPC(growslice))
	}
	if msanenabled {
		msanread(old.array, uintptr(old.len*int(et.size)))
	}

	if cap < old.cap {
		panic(errorString("growslice: cap out of range"))
	}

	if et.size == 0 {
		// append should not create a slice with nil pointer but non-zero len.
		// We assume that append doesn't need to preserve old.array in this case.
		return slice{unsafe.Pointer(&zerobase), old.len, cap}
	}

	newcap := old.cap
	doublecap := newcap + newcap
	if cap > doublecap {
		newcap = cap
	} else {
		if old.cap < 1024 {
			newcap = doublecap
		} else {
			// Check 0 < newcap to detect overflow
			// and prevent an infinite loop.
			for 0 < newcap && newcap < cap {
				newcap += newcap / 4
			}
			// Set newcap to the requested cap when
			// the newcap calculation overflowed.
			if newcap <= 0 {
				newcap = cap
			}
		}
	}

	var overflow bool
	var lenmem, newlenmem, capmem uintptr
	// Specialize for common values of et.size.
	// For 1 we don't need any division/multiplication.
	// For sys.PtrSize, compiler will optimize division/multiplication into a shift by a constant.
	// For powers of 2, use a variable shift.
	switch {
	case et.size == 1:
		lenmem = uintptr(old.len)
		newlenmem = uintptr(cap)
		capmem = roundupsize(uintptr(newcap))
		overflow = uintptr(newcap) > maxAlloc
		newcap = int(capmem)
	case et.size == sys.PtrSize:
		lenmem = uintptr(old.len) * sys.PtrSize
		newlenmem = uintptr(cap) * sys.PtrSize
		capmem = roundupsize(uintptr(newcap) * sys.PtrSize)
		overflow = uintptr(newcap) > maxAlloc/sys.PtrSize
		newcap = int(capmem / sys.PtrSize)
	case isPowerOfTwo(et.size):
		var shift uintptr
		if sys.PtrSize == 8 {
			// Mask shift for better code generation.
			shift = uintptr(sys.Ctz64(uint64(et.size))) & 63
		} else {
			shift = uintptr(sys.Ctz32(uint32(et.size))) & 31
		}
		lenmem = uintptr(old.len) << shift
		newlenmem = uintptr(cap) << shift
		capmem = roundupsize(uintptr(newcap) << shift)
		overflow = uintptr(newcap) > (maxAlloc >> shift)
		newcap = int(capmem >> shift)
	default:
		lenmem = uintptr(old.len) * et.size
		newlenmem = uintptr(cap) * et.size
		capmem, overflow = math.MulUintptr(et.size, uintptr(newcap))
		capmem = roundupsize(capmem)
		newcap = int(capmem / et.size)
	}

	// The check of overflow in addition to capmem > maxAlloc is needed
	// to prevent an overflow which can be used to trigger a segfault
	// on 32bit architectures with this example program:
	//
	// type T [1<<27 + 1]int64
	//
	// var d T
	// var s []T
	//
	// func main() {
	//   s = append(s, d, d, d, d)
	//   print(len(s), "\n")
	// }
	if overflow || capmem > maxAlloc {
		panic(errorString("growslice: cap out of range"))
	}

	var p unsafe.Pointer
	if et.ptrdata == 0 {
		p = mallocgc(capmem, nil, false)
		// The append() that calls growslice is going to overwrite from old.len to cap (which will be the new length).
		// Only clear the part that will not be overwritten.
		memclrNoHeapPointers(add(p, newlenmem), capmem-newlenmem)
	} else {
		// Note: can't use rawmem (which avoids zeroing of memory), because then GC can scan uninitialized memory.
		p = mallocgc(capmem, et, true)
		if lenmem > 0 && writeBarrier.enabled {
			// Only shade the pointers in old.array since we know the destination slice p
			// only contains nil pointers because it has been cleared during alloc.
			bulkBarrierPreWriteSrcOnly(uintptr(p), uintptr(old.array), lenmem-et.size+et.ptrdata)
		}
	}
	memmove(p, old.array, lenmem)

	return slice{p, old.len, newcap}
}

Hyleon Tsao
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Go语言之append函数
shengzhu1的博客
12-19 6860
append函数的作用 官方解释append函数是向slice里面追加一个或多个元素，然后返回一个和slice一样类型的slice，其签名为 func append(slice []T, elements...T) []T append 所做的是在切片尾添加元素并返回结果。结果需要返回因为，正如我们手写的 Append，底层的数组可能更改。 使用示例： x := []int{1,2
golang 切片 append 扩容性能分析
小知识折射大智慧
09-01 1242
很多时候，我们对这个功能点不够重视，经常也会写一些没有声明 cap 容量的变量声明，然后直接调用 append，逻辑上是没有问题的，但是当 append 的数量足够多的时候，性能问题就突出来了。
go语言切片做函数参数传递+append()函数扩容
Pistachiout的学习博客
04-13 1267
进行append后， 1. 切片没有进行扩容，那么会直接添加或修改切片指向底层数组中后一位的值，故底层数组会受到改变； 2. 而如果进行扩容，则会导致切片指向一个新的底层数组，对原来的数组是没有影响的
【转载】【Go】将切片作为参数传入函数并使用append方法遇到的问题
最新发布
hotqin888的专栏
04-22 143
因为Data是一个指向数组的指针，所以对该指针进行值拷贝时，得到的指针仍指向相同的数组，所以通过拷贝的指针对底层数组进行修改时，原切片的值也会发生相应变化。但是，我们以值传递的方式传递切片结构体的时候，同时也是传递了Len和Cap的值拷贝，因为这两个成员并不是指针，因此，当函数返回时，原切片结构体的Len和Cap并没有改变。在函数中使用append方法，切片的底层数组进行了扩容处理，因此在拷贝切片中，指针指向了新的数组，而原切片并没有指向新的数组，因此原切片不会添加新的值。
Golang数组和切片区别及切片扩容
turbock的博客
05-17 1051
1. 内部结构 1.1. 数组 Array 先说一下数组, 的确在 Go 语言中, 因为 slice 的存在, 使得 array 的出场率不高。但想要很好的理解 slice, 还是要先要了解 array. Go 语言的数组和其他语言一样, 没有什么特别的地方, 就是一段以元素类型(如int)为单位的连续内存空间。数组创建时, 被初始化为元素类型的零值. 声明举例: var arr [10]int // 长度为 10 的数组, 默认所有元素是 0 arr := [...]int{1, 2, 3} // 长度
Go语言基础语法——切片
Aaron_1997的博客
08-26 336
go中的切片可对标python中的切片，是对数组的抽象，可以理解为动态数组，可通过一个不指定大小的数组来声明一个切片 go中切片的几种常用语法的示例程序如下： 一、通过make函数定义切片及使用len()和cap()函数 实例： package main import "fmt" func main() { ////通过make函数定义切片，第二、三个参数分别是切片初始长度和切片容量 var numbers = make([]int,3,5)
golang-benchmark-append:Go的append（）与直接插入片中的基准测试
05-03
在Go语言中，`append()`函数是一个非常常用且关键的操作，它允许我们在切片（slice）上添加元素。本文将深入探讨`append()`的工作原理、性能以及与直接插入切片的差异，基于提供的"Go"标签和项目"**golang-benchmark...
Go语言入门指南大纲及框架建议：轻松掌握Go语言学习秘诀.docx
03-23
Go语言入门指南大纲及框架建议：轻松掌握Go语言学习秘诀 1. Go语言概述  Go语言的历史和创造者  Go语言的主要特性和优势  Go语言的应用领域 ... 切片的扩容与截断  append函数的使用  数组与切片的转
Go语言中文网公开课-切片实现1
08-04
在Go语言中，切片（slice）是一种非常重要的数据结构，它提供了对数组的动态视图。在本篇内容中，我们将深入探讨Go语言中的切片实现，包括切片的基本操作、内存分配以及底层结构。 1. **切片的创建与操作** - 切片...
Slices-en-Go
03-18
在Go语言中，"Slices-en-Go"这个主题主要关注的是Go语言中的切片（slices）数据结构。切片是Go语言中非常重要的一个特性，它在很多场景下都发挥着关键作用，比如动态数组、数据处理等。下面我们将深入探讨切片的基本...
sharding:Golang 的分片支持
07-09
当切片的容量不足时，可以通过 append 函数自动扩容。在分片场景中，我们可能需要将数据分布到多个切片中。例如，我们可以按照一定的规则（如哈希值、范围等）将数据分配到不同的切片，实现数据的分片存储。 3. **...
Go 的内建函数 append 为什么会返回一个新的 slice？ append添加元素到slice中，slice扩容后的细节
cool-wangtongzhou
05-10 773
本篇回答分为三个部分： 一、介绍了slice的源码结构，包含了底层数组的指针、len和cap等成员变量； 二、解答了Go的内建函数append为什么会返回一个新的slice的问题， 三、扩展了一些问题，如两个slice变量共用同一个底层数组、扩容后返回的新slice的地址变化
go语言中append方法
weixin_45533687的博客
04-29 1342
go语言中append方法
append()函数
weixin_45217447的博客
08-06 864
go 内置函数 append()说明
Golang 入门：详谈append函数
十八线Coder的博客
07-19 6961
1）刚开始的时候，切片irray1和iarray2初始长度都是7，且都指向0xc00000a240这块内存地址。（2）append对内存0xc00000a240上的值进行操作append干掉元素“2”后，其后的元素前移，所以元素“2,3,4,5”元素的位置由“3,4,5,6”代替，但是元素“6”的位置没有元素来代替它，保留原值。所以append操作完后内存0xc00000a240存的值就变为了“0,1,3,4,5,6,6”。httpshttpshttpshttpshttpshttps。...
详解Go语言中的append函数
qq_68805187的博客
09-25 1279
然后就是下一个one函数的执行,传入s2,首先为s2追加一个元素,append函数返现此时的底层数组未满(容积4,长度3),然后就正常把0加到了切片的末尾,此时底层数组容积为4,长度为4,内容为[1,2,3,0],然后执行for循环操作,底层数组的值因此就变成了[2,3,4,1],注意!- 此时s2的容积为4,长度为3,内部元素为 [1,2,3],而此时s1切片的容积为2,长度为2,内部元素为[1,2] ,此时两个切片的底层数组不是同一个。这个切片会指向新的底层数组，原始切片并没有被修改。
go语言append函数
FloraLan666的博客
01-15 904
append函数可以动态为go语言切片添加元素，每个切片会指向一个底层数组，这个数组能容纳一定数量的元素，当底层数组不能容纳新元素时，切片会自动扩容。此时的切片指向的底层数组就会更换。 package main import "fmt" func main(){ city := []string{"北京","上海","广州"} fmt.Printf("%v,len:%d,cap:%d,ptr:...
Go语言Append函数的使用
热门推荐
专注基础架构领域
11-02 1万+
1、append函数的使用 作用：在原切片的末尾添加元素 示例： package main //必须有个main包 import "fmt" func main() { s1 := []int{} fmt.Printf("len = %d, cap = %d\n", len(s1), cap(s1)) fmt.Println("s1 = ", s1) //在原切片的末尾添加元素 s1 = appe...
Golang的append函数
weixin_52767328的博客
01-29 540
Golang的append函数底层分析

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值