Why Doesn't the Capacity of a Re-sliced Go Slice Match the Original Slice's Capacity?

Re-slicing Slices in Golang: Understanding the Dynamics of Slicing

In the realm of Go programming, slicing arrays and slices is a fundamental concept. However, encountering intricacies like the one highlighted in the provided code can leave beginners baffled. Let's unravel the confusion surrounding the capacity of a re-sliced slice.

The example code demonstrates the process of creating slices from an array and then re-slicing one of those slices. However, it brings up a point of contention: why does the capacity of the re-sliced slice not match the actual capacity of the slice that it's derived from?

To understand this, we must delve into the internals of slicing in Golang. When a slice is created from an array, it essentially provides a window into that array. It doesn't create a separate copy of the elements; it merely references the underlying array. The length of the slice represents the number of elements that it currently encompasses, while its capacity indicates the maximum number of elements that it can potentially hold.

The capacity of the original slice (b in this case) is determined by the size of the array from which it was created. However, when a re-slice is performed (like creating c from b), the length of the new slice (c) is adjusted based on the provided indexes, but the capacity remains the same. This is because the re-sliced slice still shares the same underlying array as the original slice.

In other words, the capacity of a re-sliced slice is always the capacity of the original slice minus the starting index of the re-sliced slice. In the example provided, b has a capacity of 5. Since c is re-sliced starting from the 0th index, its capacity is 5 - 0 = 5. This explains why c has a capacity of 5 despite only having a length of 2.

To further illustrate this, let's modify the example code slightly:

func main() {
    b := make([]int, 0, 5)
    c := b[:2]
    d := c[1:5] // equivalent to d := b[1:5]
    d[0] = 1
    printSlice("c", c)
    printSlice("d", d)
}

In this modified code, d is a re-sliced slice of b that starts at index 1 and goes up to index 5. When we modify d by assigning the value 1 to its first element, it's interesting to observe that c is also affected. This is because both c and d are merely different windows into the same underlying array b.

The above is the detailed content of Why Doesn't the Capacity of a Re-sliced Go Slice Match the Original Slice's Capacity?. For more information, please follow other related articles on the PHP Chinese website!