使用不安全指针从 []string 获取值

Question

我正在尝试了解指针的工作原理。为什么以下示例不起作用？

package main

import (    
    "fmt"
    "unsafe"
)

type SliceOfStrings []string

// function that creates an slice of []string
// returns interface{} cause I am interested on learning how pointers work
func Create() interface{} {
    var mySlice1 SliceOfStrings = make([]string, 0)
    mySlice1 = append(mySlice1, "str1")
    mySlice1 = append(mySlice1, "str2")

    // return a slice with as ["str1","str2"]
    return mySlice1
}

func main() {

    x := Create()
    // 0xc000021940
    fmt.Printf("address of x is %p \n", &x)

    // get unsafe pointer to address of x

    // unsafe pointer. Prints 0xc000021940
    p1 := unsafe.Pointer(&x)
    fmt.Println(p1)

    // unsigned pointer. Prints 824633858368
    p2 := uintptr(p1)
    fmt.Println(p2)

    // prints same value as p1 0xc000021940
    p3 := unsafe.Pointer(p2)
    fmt.Println(p3)

    // Make p4 point to same address as 0xc000021940
    p4 := (*SliceOfStrings)(p3)
    //fmt.Println(p4)

    // why this does not print "str1" ??
    fmt.Println((*p4)[0])

    // I get error: runtime error: invalid memory address or nil pointer dereference
}

Answer 1

Create() return 是 interface{} 类型的值，所以 x 的类型是 interface{}，所以 &x 的类型是 *interface{}，并且不是 *SliceOfStrings。所以 x 指向 interface{} 值而不是 SliceOfStrings 值！

如果您从 Create() 的 return 值 type assert SliceOfStrings，它有效：

x := Create().(SliceOfStrings)

还要在你的main()末尾加上runtime.KeepAlive(x)，因为如果你不再引用x，它随时都可能被垃圾回收。

通过此更改，它可以工作并输出 str1。在 Go Playground.

上试试

一般来说，尽量远离包裹unsafe。您可以在没有包的情况下学习和使用指针 unsafe。仅将 unsafe 视为 last-last 度假胜地！

Answer 2

我能够理解为什么会这样：


package main

import (
    "fmt"
    "unsafe"
)

type SliceOfStrings []string

// when passing a slice to a method you are passing this data. Lets prove it
type SliceHeader struct {
    Data uintptr
    Len  int
    Cap  int
}



func main() {

    // On go everything is passed by coping values. When you pass a slice to a function you are passing this:
    // reference: 
    /*
        type SliceHeader struct {
            Data uintptr
            Len  int
            Cap  int
        }
    */

    // create a new slice
    var mySlice1 SliceOfStrings = make([]string, 0)

    // when appending we need to keep the new content that is why we reasig it
    mySlice1 = append(mySlice1, "str1")
    mySlice1 = append(mySlice1, "str2")
    // in other words this will make no sense:
    // _ = append(mySlice1, "str3") // doing this will lose the new header value

    // lets see the content of header mySlice
    var pointerToMySlice1 = unsafe.Pointer(&mySlice1)
    var header *SliceHeader = ((*SliceHeader)(pointerToMySlice1))
    fmt.Println(*header)
    // {824634220576 2 2}

    // lets copy that header to another slice
    var copy SliceOfStrings = mySlice1
    var pointerToCopy = unsafe.Pointer(&copy)
    header = ((*SliceHeader)(pointerToCopy))
    fmt.Println(*header)
    // prints the same thing
    // {824634220576 2 2}

    // now lets do the same thing but with an interface
    var copy2 interface{} = mySlice1
    var pointerToCopy2 = unsafe.Pointer(&copy2)
    header = ((*SliceHeader)(pointerToCopy2))
    fmt.Println(*header)
    // this prints!
    // {4845280 824634375976 0}
    // I dont understand why this happens. But this is the reason why the example does not work
    // I was trying to access an array from memory address 4845280 that is wrong

    // now lets do what izca told us
    var copy3 interface{} = mySlice1
    tmp := (copy3).(SliceOfStrings)
    var pointerToCopy3 = unsafe.Pointer(&tmp)
    header = ((*SliceHeader)(pointerToCopy3))
    fmt.Println(*header)
    // this prints!
    // {824634220576 2 2}
    // that is the correct value

    // lets try to get the array from that memory address (824634220576)
    pointerToActualArray := unsafe.Pointer(header.Data)
    // lets cast that to (*[2]string)
    var pointerFinal *[2]string = ((*[2]string)(pointerToActualArray))
    // now print the first value
    fmt.Println((*pointerFinal)[0]) 
    // prints str1
}

使用不安全指针从 []string 获取值

use unsafe pointer to get value from a []string

go

pointers

unsafe