Why Does Slice Capacity Drop When Removing Elements from the Beginning?

Mystery of the Changing Slice Capacity

A Tour of Go provides an intriguing snippet that demonstrates slice manipulation. Despite slicing the slice, leaving it with zero length, and then extending its length, the puzzle lies in why the capacity drops from 6 to 4 in the last line.

Understanding Slice Internals

To solve this enigma, it's crucial to remember that a slice stores data in an array. When the two first elements are dropped, the start of the slice is shifted to the right, leaving fewer unallocated slots between the slice's beginning point and the backing array's end.

Conversely, removing elements from the end of a slice has no impact on its capacity because the distance between the slice's starting point within the array and the end of the array remains unchanged.

It's important to note that these operations solely modify the slice structure without affecting the underlying array.

Example Explanation

By printing the slice header, we gain insight into the changes that occur:

<code class="go">func printSlice(s []int) {
    sh := (*reflect.SliceHeader)(unsafe.Pointer(&s))
    fmt.Printf("header=%+v len=%d cap=%d %v\n", sh, len(s), cap(s), s)
}</code>

In the final step, the data pointer is advanced, resulting in a reduction in capacity.

Conclusion

In this example, we observe how slicing operations can modify the slice's structure. By manipulating the pointers, capacity changes can occur based on the specific actions performed on the slice.

The above is the detailed content of Why Does Slice Capacity Drop When Removing Elements from the Beginning?. For more information, please follow other related articles on the PHP Chinese website!