golang如何使用指针灵活操作内存及unsafe包原理解析_Golang

hi 你好，我是k哥。一个大厂工作6年，还在继续搬砖的后端程序员。

我们都知道，c/c++提供了强大的万能指针void*，任何类型的指针都可以和万能指针相互转换。并且指针还可以进行加减等算数操作。那么在golang中，是否有类似的功能呢？答案是有的，这就是我们今天要探讨的unsafe包。

本文将深入探讨unsafe包的功能和原理。同时，我们学习某种东西，一方面是为了实践运用，另一方面则是出于功利性面试的目的。所以，本文还会为大家介绍unsafe 包的典型应用以及高频面试题。

功能

为了实现灵活操作内存的目的，unsafe包主要提供了4个功能：

定义了pointer类型，任何类型的指针都可和pointer互相转换，类似于c语言中的void*

var a int = 1
p := unsafe.pointer(&a) // 其它类型指针转pointer
b := (*int)(p) // pointer类型转其它类型指针
fmt.println(*b) // 输出1

定义了uintptr类型，pointer和uintptr可以互相转换， 从而实现指针的加减等算数运算。

type person struct {
    age int
    name string
}
person := person{age:18,name:"k哥"}
p := unsafe.pointer(&person) // 其它类型指针转pointer
u := uintptr(p) // pointer类型转为uintptr
u=u+8 // uintptr加减操作
pname := unsafe.pointer(u) // uintptr转换为pointer
name := *(*string)(pname)
fmt.println(name) // 输出k哥

uintptr是用于指针运算的，它只是一个存储一个 指针地址 的 int 类型，gc 不把 uintptr 当指针，因此， uintptr 类型的目标可能会被回收

获取任意类型内存对齐、偏移量和内存大小。

func alignof(x arbitrarytype) uintptr // 内存对齐
func offsetof(x arbitrarytype) uintptr // 内存偏移量
func sizeof(x arbitrarytype) uintptr // 内存大小

alignof 返回类型x的内存地址对齐值m，这个类型在内存中的地址必须是m的倍数(基于内存读写性能的考虑)。
offsetof 返回结构体成员x在内存中的位置离结构体起始处(结构体的第一个字段的偏移量都是0)的字节数，即偏移量。
sizeof 返回类型 x 所占据的字节数，如果类型x结构有指针，sizeof不包含 x 指针成员所指向内容的大小。

arbitrarytype是占位符，golang编译器在编译时会替换为具体类型

高性能类型转换。

func slice(ptr *arbitrarytype, len integertype) []arbitrarytype
func slicedata(slice []arbitrarytype) *arbitrarytype
func string(ptr *byte, len integertype) string 
func stringdata(str string) *byte

slice 传入任意类型的指针和长度，返回该类型slice变量
slicedata 传入任意类型的slice变量，返回该slice底层数组的指针。
string 从一个byte指针派生出一个指定长度的字符串。
stringdata 用来获取一个字符串底层字节序列中的第一个byte的指针。

高性能类型转换原理

为什么说slice、slicedata、string、stringdata是高性能类型转换函数呢?下面我们就来剖析下它们的实现原理。

本文以string和stringdata函数为例，slice和slicedata函数实现原理类似。在介绍函数实现原理之前，先认识下string类型的底层数据结构stringheader。string类型会被golang编译器编译成此结构，其中data是byte数组地址，len是字符串长度。

type stringheader struct {
        data uintptr // byte数组地址
        len  int // 字符串长度
}

string函数会被go编译成下面的函数实现逻辑。我们可以发现，ptr指针转换为string类型，是直接将ptr赋值给stringheader的成员data，而不需要重新拷贝ptr指向的byte数组。从而通过零拷贝实现高性能类型转换。

import (
    "fmt"
    "reflect"
    "unsafe"
)
func string(ptr *byte, len int) string {
    p := (uintptr)(unsafe.pointer(ptr))
    hdr := &reflect.stringheader{
        data: p,
        len:  len,
    }
    // 将 stringheader 转为 string
    str := *(*string)(unsafe.pointer(hdr))
    return str
}
func main() {
    bytes := []byte{'h', 'e', 'l', 'l', 'o'}
    ptr := &bytes[0]
    len := 5
    str := string(ptr, len)
    fmt.println(str) // 输出hello
}

stringdata函数会被go编译成下面的函数实现逻辑。同理，我们可以发现，string类型转换为byte，是直接取stringheader的uintptr类型成员data，并将其转换为byte。不需要拷贝整个string，重新生成byte数组。从而通过零拷贝实现高性能类型转换。

import (
    "fmt"
    "reflect"
    "unsafe"
)
func stringdata(str string) *byte {
    hdr := (*reflect.stringheader)(unsafe.pointer(&str))
    data := hdr.data
    return (*byte)(unsafe.pointer(data))
}
func main() {
    str := "hello"
    data := stringdata(str)
    fmt.println(string(*data)) // 输出h
}

回到问题，为什么说slice、slicedata、string、stringdata是高性能类型转换函数呢？通过string和stringdata函数的实现逻辑，我们可以知道，string和stringdata利用unsafe包，通过零拷贝，实现了高性能类型转换。

典型应用

在实践中，常见使用unsafe包的场景有2个：

与操作系统以及非go编写(cgo)的代码通信。

func setdata(bytes []byte) { 
    cstr := (*c.char)(unsafe.pointer(&bytes[0])) // 转换成一个c char类型
    c.setdata(cstr, (c.int)(len(bytes))) // 调用c语言函数
}

高性能类型转换。

func bytes2string(b []byte) string {
    return *(*string)(unsafe.pointer(&b))
}
func string2bytes(s string) []byte {
    sh := (*reflect.stringheader)(unsafe.pointer(&s))
    bh := reflect.sliceheader{
        data: sh.data,
        len:  sh.len,
        cap:  sh.len,
    }
    return *(*[]byte)(unsafe.pointer(&bh))
}