By

文章目录

前几天使用golang时，遇到一个很奇怪的问题，原因是对golang不熟悉，所以记录一下。

在使用append()函数给slice中添加元素时，slice的初始大小可以为0，也就是len可以为0。每次向slice中append的时候，如果容量cap不够，会自动对slice进行扩容，也就是改变slice的cap的大小。

而在使用copy()函数操作slice时，如果slice的大小为0时，会不添加任何元素，不会自动增加slice的容量大小。这里要注意。

下面是从golang官网源码库中看到的实现代码，如下所示：

  • runtime/slice.go
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
func slicecopy(to, fm slice, width uintptr) int {
    if fm.len == 0 || to.len == 0 {
        return 0
    }

    n := fm.len
    if to.len < n {
        n = to.len
    }

    if width == 0 {
        return n
    }

    if raceenabled {
        callerpc := getcallerpc(unsafe.Pointer(&to))
        pc := funcPC(slicecopy)
        racewriterangepc(to.array, uintptr(n*int(width)), callerpc, pc)
        racereadrangepc(fm.array, uintptr(n*int(width)), callerpc, pc)
    }
    if msanenabled {
        msanwrite(to.array, uintptr(n*int(width)))
        msanread(fm.array, uintptr(n*int(width)))
    }

    size := uintptr(n) * width
    if size == 1 { // common case worth about 2x to do here
        // TODO: is this still worth it with new memmove impl?
        *(*byte)(to.array) = *(*byte)(fm.array) // known to be a byte pointer
    } else {
        memmove(to.array, fm.array, size)
    }
    return n
}

从上面的代码可以看出来，如果slice的len值为0，则直接return，不会进行复制操作。

下面是示例代码，验证一下：

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
package main

import (
    "regexp"
    "log"
    "unsafe"
)

func init()  {
    log.SetFlags(log.Lshortfile|log.LstdFlags)
}

func sliceTest(list []int)  {
    if len(list) > 0 {
        log.Println("func pos 0:", &list[0])
    }

    log.Println("func pointer:", unsafe.Pointer(&list))
    log.Println("------")
}

func copyTest()  {
    list := make([]int, 0)
    log.Println("pointer:", unsafe.Pointer(&list))
    sliceTest(list)
    log.Println("++++++++++++++")

    list = append(list, 1)
    log.Println("pos 0:", &list[0])
    log.Println("pointer:", unsafe.Pointer(&list))
    sliceTest(list)
    log.Println("++++++++++++++")

    list = append(list, 2)
    log.Println("pos 0:", &list[0])
    log.Println("pointer:", unsafe.Pointer(&list))
    sliceTest(list)
    log.Println("++++++++++++++")

    copy1 := make([]int, 0)
    copy(copy1, list)
    log.Println("copy1:", copy1)

    copy2 := make([]int, 2)
    copy(copy2, list)
    log.Println("copy2:", copy2)

    copy3 := make([]int, 0, 2)
    copy(copy3, list)
    log.Println("copy3:", copy3)
    log.Println()
}


func main() {
    copyTest()
}

输出：

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

pointer: 0xc42000a060
func pointer: 0xc42000a080
------
++++++++++++++
pos 0: 0xc4200160d0
pointer: 0xc42000a060
func pos 0: 0xc4200160d0
func pointer: 0xc42000a0a0
------
++++++++++++++
pos 0: 0xc4200160f0
pointer: 0xc42000a060
func pos 0: 0xc4200160f0
func pointer: 0xc42000a0c0
------
++++++++++++++
copy1: []
copy2: [1 2]
copy3: []

从上面的日志可以看出来，copy1和copy3都是空，没有进行复制操作；每次进行扩容的时候，pos 0:的地址都会发生变化。另外还可以看出来，当把slice传给一个函数时，对slice的结构体发生的值传递，而slice中指向数据内容的地址没有变，即上面pos 0:和func pos 0:输出的地址是一致。

同样可以在runtime/slice.go源码中的makeslice()函数中可以看到创建的slice结构体，如下所示：

1
2
3
4
5
type slice struct {
    array unsafe.Pointer
    len   int
    cap   int
}

也就是说当把slice直接传给函数时，会对这个slice结构体内容进行复制，而array的地址不会变，始终指向数组内容的首元素地址。

另外看这个runtime/slice.go的源码时，还发现一个有趣的细节，代码如下所示：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
func growslice(et *_type, old slice, cap int) slice {
    // ...

    newcap := old.cap
    doublecap := newcap + newcap
    if cap > doublecap {
        newcap = cap
    } else {
        if old.len < 1024 {
            newcap = doublecap
        } else {
            for newcap < cap {
                newcap += newcap / 4
            }
        }
    }

    // ...
}

在slice进行扩容的时候，如果其容量小于1024，则容量增加一倍；否则容量以1.25倍的数量增加。

以上golang源码是基于1.9.1版本。

文章目录