How Do Go Slices Relate to Their Underlying Arrays?

Understanding Slices and Their Underlying Arrays in Go

In Go, a slice represents a contiguous segment of an underlying array. Slicing an array creates a new slice that references the same underlying array as the original, but with its own length and capacity.

Consider the following example where a slice is created from an array:

nums := [3]int{1, 2, 3}
numSlice := nums[:2]

In this case, the slice numSlice contains the first two elements of the array nums. However, both the slice numSlice and the original array nums point to the same underlying array in memory.

Adding elements to the slice modifies the underlying array. However, if the slice's capacity limit is reached, the underlying array needs to be resized to accommodate the additional elements.

To access the underlying array of a slice, you can use the reflect and unsafe packages in Go. The reflect.SliceHeader type provides access to the underlying array's pointer.

s := []int{1, 2, 3, 4}
hdr := (*reflect.SliceHeader)(unsafe.Pointer(&s))
data := *(*[4]int)(unsafe.Pointer(hdr.Data))

This code retrieves the underlying array as a pointer to a typed array (*[4]int), making it possible to modify the array directly.

The above is the detailed content of How Do Go Slices Relate to Their Underlying Arrays?. For more information, please follow other related articles on the PHP Chinese website!