Why is a Slice Created with `reflect.MakeSlice` Not Addressable?

Why Does Reflect.MakeSlice Return an Un-addressable Value?

In Go, addressability refers to the ability to obtain the memory address of a variable and guarantee its validity. Local stack variables are not addressable, and this concept applies to values created using reflect.MakeSlice.

When using reflect.MakeSlice, you create a new slice value. However, this value is not stored in a memory location with a known address. Instead, it exists temporarily on the stack. This stack-allocated value cannot be used to create a pointer to a slice because the address would become invalid when the stack frame is destroyed.

Obtaining an Addressable Slice Value

To resolve this issue and obtain an addressable slice value, you can use reflect.New(). This function creates a pointer to the slice:

myType := reflect.TypeOf(my)
slice := reflect.MakeSlice(reflect.SliceOf(myType), 10, 10)
x := reflect.New(slice.Type()).Elem()
x.Set(slice)

The x.Elem() call dereferences the pointer and returns the actual slice value, which can now be used to pass to the All() method.

Understanding Addressability in Go

According to the Go language specification, a value is addressable if it is:

• An element of a slice
• An element of an addressable array
• A field of an addressable struct
• The result of dereferencing a pointer

In the case of reflect.MakeSlice, the newly created slice does not meet any of these criteria because it exists on the stack and is not stored in a permanent memory location.

The above is the detailed content of Why is a Slice Created with `reflect.MakeSlice` Not Addressable?. For more information, please follow other related articles on the PHP Chinese website!