Golang：附加或不分配分配的切片

Question

Go 的 append() 函数仅在给定切片的容量不足时分配新的切片数据（另请参见：https://stackoverflow.com/a/28143457/802833）。这可能会导致意外行为（至少对于我作为 golang 新手而言）：

package main

import (
    "fmt"
)

func main() {

    a1 := make([][]int, 3)
    a2 := make([][]int, 3)
    b := [][]int{{1, 1, 1}, {2, 2, 2}, {3, 3, 3}}
    common1 := make([]int, 0)
    common2 := make([]int, 0, 12) // provide sufficient capacity
    common1 = append(common1, []int{10, 20}...)
    common2 = append(common2, []int{10, 20}...)

    idx := 0
    for _, k := range b {
        a1[idx] = append(common1, k...) // new slice is allocated
        a2[idx] = append(common2, k...) // no allocation
        idx++
    }

    fmt.Println(a1)
    fmt.Println(a2) // surprise!!!
}

输出：

[[10 20 1 1 1] [10 20 2 2 2] [10 20 3 3 3]]

[[10 20 3 3 3] [10 20 3 3 3] [10 20 3 3 3]]

https://play.golang.org/p/8PEqFxAsMt

那么，Go 中强制分配新切片数据或更准确地说是确保 append() 的切片参数保持不变的（惯用）方式是什么？

Answer 1

你可能对 Go 中切片的工作方式有一个错误的想法。

当您将元素附加到切片时，对append() 的调用会返回一个新切片。如果没有发生重新分配，两个切片值——你调用append()的那个和它返回的那个——共享相同的后备数组但是它们会有不同的长度；观察：

package main

import "fmt"

func main() {
    a := make([]int, 0, 10)
    b := append(a, 1, 2, 3)
    c := append(a, 4, 3, 2)
    fmt.Printf("a=%#v\nb=%#v\nc=%#v\n", a, b, c)
}

输出：

a=[]int{}
b=[]int{4, 3, 2}
c=[]int{4, 3, 2}

所以，len(a) == 0、len(b) == 3、len(c) == 3 以及对 append() 的第二次调用写出了第一次的作用，因为所有切片共享同一个底层数组。

关于后备数组的重新分配，the spec 很清楚：

如果 s 的容量不足以容纳附加值，则 append 分配一个新的、足够大的底层数组，该数组既适合现有的切片元素又适合附加值。否则，追加重用底层数组。

由此可知：

1. append() 绝不会在附加到的切片容量足够的情况下复制底层存储。
2. 如果容量不足，将重新分配数组。

也就是说，给定一个切片 s，您希望将 N 元素附加到该切片上，如果 cap(s) - len(s) ≥ N 则不会进行重新分配。

因此，我怀疑您的问题不在于意外的重新分配结果，而在于 Go 中实现的切片的概念。要吸收的代码思想是 append() 返回结果切片值， 你应该在调用之后使用它除非你完全理解后果。 p>

我建议从this 开始以完全理解它们。

Answer 2

感谢您的反馈。

因此，获得对内存分配的控制权的解决方案是明确地进行（这让我想起 Go 比其他（脚本）语言更像是一种系统语言）：

package main

import (
    "fmt"
)

func main() {

    a1 := make([][]int, 3)
    a2 := make([][]int, 3)
    b := [][]int{{1, 1, 1}, {2, 2, 2}, {3, 3, 3}}
    common1 := make([]int, 0)
    common2 := make([]int, 0, 12) // provide sufficient capacity
    common1 = append(common1, []int{10, 20}...)
    common2 = append(common2, []int{10, 20}...)

    idx := 0
    for _, k := range b {
        a1[idx] = append(common1, k...) // new slice is allocated
        
        a2[idx] = make([]int, len(common2), len(common2)+len(k))
        copy(a2[idx], common2)      // copy & append could probably be
        a2[idx] = append(a2[idx], k...) // combined into a single copy step
        
        idx++
    }

    fmt.Println(a1)
    fmt.Println(a2)
}

输出：

[[10 20 1 1 1] [10 20 2 2 2] [10 20 3 3 3]]

[[10 20 1 1 1] [10 20 2 2 2] [10 20 3 3 3]]

https://play.golang.org/p/Id_wSZwb84