Why Does Re-slicing a Go Slice Change Its Capacity?

Re-slicing Slices in Golang

In Golang, slices are flexible data structures that allow for dynamic resizing. However, understanding the behavior of re-slicing slices can be confusing. Let's delve into the code provided and explain the puzzling behavior of c's capacity:

func main() {
    b := make([]int, 0, 5) // Create an empty slice with a capacity of 5
}

Here, b is initially empty, but it has a capacity of 5. This means that the underlying array can hold up to 5 elements.

c := b[:2] // Create a slice c from b, starting at the beginning (index 0) and ending just before index 2

Now, c is a slice referencing the first two elements of b. However, c does not create a copy of the underlying array. It is still a window into b.

printSlice("c", c) // Print the length, capacity, and elements of c
// Output: c len=2 cap=5 [0 0]

As expected, c has a length of 2 and a capacity of 5. This is because c can still access the entire array represented by b, with the remaining 3 unused elements potentially accessible through extension.

d := c[2:5] // Create a slice d from c, starting at index 2 and ending at the end (index 5)

Here, d is a slice referencing the elements of c from index 2 to the end (index 5). Since c has a capacity of 5, d can extend up to 3 elements further.

printSlice("d", d) // Print the length, capacity, and elements of d
// Output: d len=3 cap=3 [0 0 0]

d has a length of 3 because it references the remaining elements of c, and a capacity of 3 because it can accommodate up to 3 more elements within b.

In conclusion, the capacity of a slice is determined by the underlying array's capacity and the starting position of the slice within that array. By understanding this relationship, developers can effectively manipulate slices and control their behavior in Golang programs.

The above is the detailed content of Why Does Re-slicing a Go Slice Change Its Capacity?. For more information, please follow other related articles on the PHP Chinese website!