How Can I Access the Underlying Array of a Go Slice?

Understanding Go Slices and How to Obtain Their Underlying Array

In Go, slices are a flexible data structure that represent a contiguous section of an underlying array. When working with slices, it's often useful to understand the mechanics behind their manipulation and how to access the underlying array.

Let's consider a specific scenario:

Suppose we have an array of integers of length 3:

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

If we create a slice of the first two elements:

numSlice := nums[:2]

Both numSlice and nums have a capacity of 3 (the maximum number of elements they can hold) and a length of 2 and 3, respectively. Adding an element to numSlice with append(numSlice, 10) modifies the underlying array nums because the slice still uses the same array.

However, if we append again to numSlice with append(numSlice, 20), the underlying array must change. This is reflected in numSlice's capacity doubling and its length increasing to 4.

To access the new underlying array, a combination of reflection and unsafe operations is required. reflect.SliceHeader contains a Data field that points to the underlying array of a slice.

Example:

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

This provides a way to directly manipulate the underlying array of a slice. However, it's important to note that unsafe operations should be used with caution and may lead to undefined behavior if not handled properly.

The above is the detailed content of How Can I Access the Underlying Array of a Go Slice?. For more information, please follow other related articles on the PHP Chinese website!