从字符串中提取值的不安全指针使用

本篇文章给大家分享《从字符串中提取值的不安全指针使用》，覆盖了Golang的常见基础知识，其实一个语言的全部知识点一篇文章是不可能说完的，但希望通过这些问题，让读者对自己的掌握程度有一定的认识(B 数)，从而弥补自己的不足，更好的掌握它。

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

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
}

正确答案

create() 返回 interface{} 类型的值，因此 x 的类型为 interface{}，因此 &x 的类型为 *interface{}，而不是 * sliceofstrings。因此 x 指向 interface{} 值，而不是 sliceofstrings 值！

如果您从 create() 的返回值中获取 type assert sliceofstrings，则它可以工作：

x := create().(sliceofstrings)

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

通过此更改，它可以工作并输出 str1。在 Go Playground 上尝试一下。

一般来说，尽可能远离软件包 unsafe。您可以在没有包 unsafe 的情况下学习和使用指针。仅将 unsafe 作为最后的手段！

我能够理解为什么会发生这种情况：

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: https://stackoverflow.com/a/39993797/637142
    /*
        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(©)
    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(©2)
    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
}

以上就是《从字符串中提取值的不安全指针使用》的详细内容，更多关于的资料请关注golang学习网公众号！