1
2
3
4
5
6
7

	list1 := make([]int, 0)
	
	var list2 []int
	
	list3 := make([]int, 0,10)
	
	list4 := []int{1,4}

1
2
3
4
5

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

1
2

	arr := []int{1,2,3,4,5}
	fmt.Println(arr[1:4])//[2,3,4]

1
2
3
4
5

type SliceHeader struct {
	Data uintptr
	Len  int
	Cap  int
}

1
2
3

	arr := []int{1,2,3,4,5}
	arr = append(arr, 9)
	//[1,2,3,4,5,9]

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68

func growslice(oldPtr unsafe.Pointer, newLen, oldCap, num int, et *_type) slice {
	oldLen := newLen - num

	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 oldPtr in this case.
		return slice{unsafe.Pointer(&zerobase), newLen, newLen}
	}

	newcap := nextslicecap(newLen, oldCap)

	var overflow bool
	var lenmem, newlenmem, capmem uintptr
	noscan := et.PtrBytes == 0
	switch {
	case et.Size_ == 1:
		lenmem = uintptr(oldLen)
		newlenmem = uintptr(newLen)
		capmem = roundupsize(uintptr(newcap), noscan)
		overflow = uintptr(newcap) > maxAlloc
		newcap = int(capmem)
	case et.Size_ == goarch.PtrSize:
		lenmem = uintptr(oldLen) * goarch.PtrSize
		newlenmem = uintptr(newLen) * goarch.PtrSize
		capmem = roundupsize(uintptr(newcap)*goarch.PtrSize, noscan)
		overflow = uintptr(newcap) > maxAlloc/goarch.PtrSize
		newcap = int(capmem / goarch.PtrSize)
	case isPowerOfTwo(et.Size_):
		var shift uintptr
		if goarch.PtrSize == 8 {
			// Mask shift for better code generation.
			shift = uintptr(sys.TrailingZeros64(uint64(et.Size_))) & 63
		} else {
			shift = uintptr(sys.TrailingZeros32(uint32(et.Size_))) & 31
		}
		lenmem = uintptr(oldLen) << shift
		newlenmem = uintptr(newLen) << shift
		capmem = roundupsize(uintptr(newcap)<<shift, noscan)
		overflow = uintptr(newcap) > (maxAlloc >> shift)
		newcap = int(capmem >> shift)
		capmem = uintptr(newcap) << shift
	default:
		lenmem = uintptr(oldLen) * et.Size_
		newlenmem = uintptr(newLen) * et.Size_
		capmem, overflow = math.MulUintptr(et.Size_, uintptr(newcap))
		capmem = roundupsize(capmem, noscan)
		newcap = int(capmem / et.Size_)
		capmem = uintptr(newcap) * et.Size_
	}
	
	if overflow || capmem > maxAlloc {
		panic(errorString("growslice: len out of range"))
	}

	var p unsafe.Pointer
	if et.PtrBytes == 0 {
		p = mallocgc(capmem, nil, false)
		memclrNoHeapPointers(add(p, newlenmem), capmem-newlenmem)
	} else {
		p = mallocgc(capmem, et, true)
		if lenmem > 0 && writeBarrier.enabled {
			bulkBarrierPreWriteSrcOnly(uintptr(p), uintptr(oldPtr), lenmem-et.Size_+et.PtrBytes, et)
		}
	}
	memmove(p, oldPtr, lenmem)

	return slice{p, newLen, newcap}
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

func nextslicecap(newLen, oldCap int) int {
	newcap := oldCap
	doublecap := newcap + newcap
	if newLen > doublecap {
		return newLen
	}

	const threshold = 256
	if oldCap < threshold {
		return doublecap
	}
	for {
		newcap += (newcap + 3*threshold) >> 2
		
		if uint(newcap) >= uint(newLen) {
			break
		}
	}
	
	if newcap <= 0 {
		return newLen
	}
	return newcap
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

func main() {
	arr := []int{1}
	fmt.Println(cap(arr))//1

	arr = append(arr, 2, 3)
	fmt.Println(cap(arr))//3

	arr = append(arr, 4, 5, 6, 7)
	fmt.Println(cap(arr))//8
}

1
2
3
4

(size+smallSizeDiv-1)/smallSizeDiv = (56 + 8 - 1) / 8 = 7
size_to_class8[7] = 5
class_to_size[5] = 64 所以 roundopsize 的返回值为 64 
newcap = int(capmem / ptrSize) = int(64 / 8) = 8 ，所以最终原切片的容量扩充到了 8

1
2
3
4

(size+smallSizeDiv-1)/smallSizeDiv = (56 + 8 - 1) / 8 = 7
size_to_class8[7] = 5
class_to_size[5] = 64 所以 roundopsize 的返回值为 64 
newcap = int(capmem / ptrSize) = int(64 / 8) = 8 ，所以最终原切片的容量扩充到了 8