dpb56083
2017-03-01 11:13
浏览 298
已采纳

在Go函数中返回局部数组的切片安全吗?

What happens if I return a slice of an array that is a local variable of a function or method? Does Go copy the array data into a slice create with make()? Will the capacity match the slice size or the array size?

func foo() []uint64 {
    var tmp [100]uint64
    end := 0
    ...
    for ... {
        ...
        tmp[end] = uint64(...)
        end++
        ...
    }
    ... 
    return tmp[:end]
} 

图片转代码服务由CSDN问答提供 功能建议

如果我返回作为函数或方法的局部变量的数组的切片会发生什么? Go是否会将数组数据复制到使用 make()创建的切片中? 容量会匹配切片大小还是数组大小?

  func foo()[] uint64 {
 var tmp [100] uint64 
 end:= 0 
  ... 
 for ... {
 ... 
 tmp [end] = uint64(...)
 end ++ 
 ... 
} 
 ... 
返回tmp [: 结束] 
} 
   
 
  • 写回答
  • 关注问题
  • 收藏
  • 邀请回答

3条回答 默认 最新

  • doudao1950 2017-03-01 11:23
    已采纳

    This is detailed in Spec: Slice expressions.

    The array will not be copied, but instead the result of the slice expression will be a slice that refers to the array. In Go it is perfectly safe to return local variables or their addresses from functions or methods, the Go compiler performs an escape analysis to determine if a value may escape the function, and if so (or rather if it can't prove that a value may not escape), it allocates it on the heap so it will be available after the function returns.

    The slice expression: tmp[:end] means tmp[0:end] (because a missing low index defaults to zero). Since you didn't specify the capacity, it will default to len(tmp) - 0 which is len(tmp) which is 100.

    You can also control the result slice's capacity by using a full slice expression, which has the form:

    a[low : high : max]
    

    Which sets the resulting slice's capacity to max - low.

    More examples to clarify the resulting slice's length and capacity:

    var a [100]int
    
    s := a[:]
    fmt.Println(len(s), cap(s)) // 100 100
    s = a[:50]
    fmt.Println(len(s), cap(s)) // 50 100
    s = a[10:50]
    fmt.Println(len(s), cap(s)) // 40 90
    s = a[10:]
    fmt.Println(len(s), cap(s)) // 90 90
    
    s = a[0:50:70]
    fmt.Println(len(s), cap(s)) // 50 70
    s = a[10:50:70]
    fmt.Println(len(s), cap(s)) // 40 60
    s = a[:50:70]
    fmt.Println(len(s), cap(s)) // 50 70
    

    Try it on the Go Playground.

    Avoiding heap allocation

    If you want to allocate it on the stack, you can't return any value that points to it (or parts of it). If it would be allocated on the stack, there would be no guarantee that after returning it remains available.

    A possible solution to this would be to pass a pointer to an array as an argument to the function (and you may return a slice designating the useful part that the function filled), e.g.:

    func foo(tmp *[100]uint64) []uint64 {
        // ...
        return tmp[:end]
    }
    

    If the caller function creates the array (on the stack), this will not cause a "reallocation" or "moving" to the heap:

    func main() {
        var tmp [100]uint64
        foo(&tmp)
    }
    

    Running go run -gcflags '-m -l' play.go, the result is:

    ./play.go:8: leaking param: tmp to result ~r1 level=0
    ./play.go:5: main &tmp does not escape
    

    The variable tmp is not moved to heap.

    Note that [100]uint64 is considered a small array to be allocated on the stack. For details see What is considered "small" object in Go regarding stack allocation?

    打赏 评论
  • doudiyu1639 2017-03-01 11:24

    The data is not copied. The array will be used as the underlying array of the slice.

    It looks like you're worrying about the life time of the array, but the compiler and garbage collector will figure that out for you. It's as safe as returning pointers to "local variables".

    打赏 评论
  • douwa1304 2017-03-01 11:27

    Nothing wrong happens.

    Go does not make a copy but compiler performs escape analysis and allocates the variable that will be visible outside function on heap.

    The capacity will be the capacity of underlying array.

    打赏 评论

相关推荐 更多相似问题