Why does the slice capacity decrease when dropping the first two elements in Go Tour slide 11, but not when extending the slice length?

Understanding Slice Capacity Changes in the Go Tour #11

The Go Tour provides insightful demonstrations of the language's features, including slices. In slide 11, a slice of integers is manipulated to demonstrate its properties. However, one observation raises a question: why does the slice capacity change in the last line, while it remains unchanged in the previous operations?

Understanding the Effects of Slice Manipulation on Capacity

Slice capacity refers to the maximum number of elements the underlying array can hold before reallocation is required. The Go Tour code snippet performs the following operations:

1. Creation: An initial slice s is created with a length and capacity of 6.
2. Slicing to Zero Length: s[:0] creates a new slice starting from the beginning of s and ending at index 0, effectively truncating it to zero length. The capacity remains 6 because no elements are removed from the backing array.
3. Extending Slice Length: s[:4] extends the slice to include the first four elements. The capacity remains 6 since there is still space in the backing array.
4. Dropping First Two Values: s[2:] removes the first two elements of s, but the capacity decreases to 4. This happens because the slice still holds the remaining elements, and the distance between the start of the slice (s[2]) and the end of the backing array has decreased.

Reasons for Capacity Reduction in the Last Line

• Movement of Slice Data Pointer: Dropping the first two elements moves the slice data pointer two positions to the right. This effectively reduces the distance between the start of the slice and the end of the backing array.
• No Impact on Backing Array: All slice operations modify only the slice header, not the backing array. The backing array remains unchanged, with a capacity of 6.

Visualizing the Header Changes

The following code prints the slice header, which provides additional insights into the changes:

<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>

The output shows that the header Data pointer moves from 272990208 to 272990216 when the first two elements are dropped, reducing the slice capacity.

The above is the detailed content of Why does the slice capacity decrease when dropping the first two elements in Go Tour slide 11, but not when extending the slice length?. For more information, please follow other related articles on the PHP Chinese website!