Why in Go language, the value returned by the cap function after slicing operation is 6 instead of 5?

Detailed explanation of the Go slicing capacity growth mechanism: Why is cap(s) 6 instead of 5?

This article discusses the reason why the return value of cap function is greater than the slice length after slicing operation in Go. The following example shows the changes in slice length ( len ) and capacity ( cap ) after the append operation:

 package main

import "fmt"

func main() {
    var s []int
    printSlice(s) // len=0 cap=0 []

    s = append(s, 0)
    printSlice(s) // len=1 cap=1 [0]

    s = append(s, 1)
    printSlice(s) // len=2 cap=2 [0 1]

    s = append(s, 2, 3, 4)
    printSlice(s) // len=5 cap=6 [0 1 2 3 4]
}

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

After adding elements 2, 3, 4, len(s) is 5, but cap(s) becomes 6. This is because the slicing underlying implementation of Go language adopts a growth strategy designed to balance memory usage and performance. Go will not allocate just enough memory every time, because frequent memory allocation and data copying will reduce efficiency.

The slicing capacity growth strategy of Go language does not grow linearly. The specific algorithm is defined in the Go source code and may vary by version. Generally speaking, capacity will increase in a certain proportion (for example, doubling or calculated according to a certain formula) to reduce the frequency of reallocating memory when append again in the future. In the example, capacity grows from 2 to 6, a common growth strategy that reserves additional space to avoid frequent triggering of memory redistribution when a small number of elements is added, thereby improving performance. This complies with the principle of cap >= len , ensuring that the slice always has enough capacity to accommodate more elements.

(Image description: Schematic diagram of the capacity growth of Go language, showing the nonlinear growth of capacity)

In short, cap(s) is 6 instead of 5, which is a pre-allocation strategy adopted by Go to optimize performance, not a mistake. This strategy can improve program efficiency in most cases and avoid frequent memory allocation and data copying.

The above is the detailed content of Why in Go language, the value returned by the cap function after slicing operation is 6 instead of 5?. For more information, please follow other related articles on the PHP Chinese website!