网站首页 返回列表像“草根”一样，紧贴着地面，低调的存在，冬去春来，枯荣无恙。

Golang unsafe包使用

2020-06-10 02:59:17 admin 536

unsafe包提供了访问底层内存的方法。是用unsafe函数可以提高访问对象的速度。通常用于对大数组的遍历。

## unsafe内容介绍

func Alignof(x ArbitraryType) uintptr
    func Offsetof(x ArbitraryType) uintptr
    func Sizeof(x ArbitraryType) uintptr
    type ArbitraryType int
    type Pointer *ArbitraryType

* 通过指针加偏移量的操作，在地址中，修改，访问变量的值

这个包中，只提供了3个函数，两个类型

unsafe中，通过这两个个兼容万物的类型，将其他类型都转换过来，然后通过这三个函数，分别能取长度，偏移量，对齐字节数，就可以在内存地址映射中，来回游走。放在c语言中，是不是，只要给你一个起始地址，你就一下子干到底！！！在golang中，通过unsafe包，你也可以尽情的去放纵

uintptr：用于指针运算，GC 不把 uintptr 当指针，uintptr 无法持有对象。uintptr 类型的目标会被回收。

unsafe.Pointer 可以和 普通指针 进行相互转换。

unsafe.Pointer 可以和 uintptr 进行相互转换。

也就是说 unsafe.Pointer 是桥梁，可以让任意类型的指针实现相互转换，也可以将任意类型的指针转换为 uintptr 进行指针运算。

## 详细说明

* type ArbitraryType int

是int的一个别名，但是golang中，对ArbitraryType赋予了特殊的意义，

* type Pointer *ArbitraryType

是int指针类型的一个别名，在golang系统中，可以把Pointer类型，理解成任何指针的亲爹。

* func Alignof(x ArbitraryType) uintptr

Alignof返回变量对齐字节数量

* func Offsetof(x ArbitraryType) uintptr

Offsetof返回变量指定属性的偏移量，这个函数虽然接收的是任何类型的变量，但是这个又一个前提，就是变量要是一个struct类型，且还不能直接将这个struct类型的变量当作参数，只能将这个struct类型变量的属性当作参数。

* func Sizeof(x ArbitraryType) uintptr

Sizeof 返回变量在内存中占用的字节数，切记，如果是slice，则不会返回这个slice在内存中的实际占用长度。

## 示例

### 通过指针修改结构体字段

package main
    
    import (
        "fmt"
        "unsafe"
    )
    
    func main() {
        s := struct {
            a byte
            b byte
            c byte
            d int64
        }{0, 0, 0, 0}
    
        // 将结构体指针转换为通用指针
        p := unsafe.Pointer(&s)
        // 保存结构体的地址备用（偏移量为 0）
        up0 := uintptr(p)
        // 将通用指针转换为 byte 型指针
        pb := (*byte)(p)
        // 给转换后的指针赋值
        *pb = 10
        // 结构体内容跟着改变
        fmt.Println(s)
    
        // 偏移到第 2 个字段
        up := up0 + unsafe.Offsetof(s.b)
        // 将偏移后的地址转换为通用指针
        p = unsafe.Pointer(up)
        // 将通用指针转换为 byte 型指针
        pb = (*byte)(p)
        // 给转换后的指针赋值
        *pb = 20
        // 结构体内容跟着改变
        fmt.Println(s)
    
        // 偏移到第 3 个字段
        up = up0 + unsafe.Offsetof(s.c)
        // 将偏移后的地址转换为通用指针
        p = unsafe.Pointer(up)
        // 将通用指针转换为 byte 型指针
        pb = (*byte)(p)
        // 给转换后的指针赋值
        *pb = 30
        // 结构体内容跟着改变
        fmt.Println(s)
    
        // 偏移到第 4 个字段
        up = up0 + unsafe.Offsetof(s.d)
        // 将偏移后的地址转换为通用指针
        p = unsafe.Pointer(up)
        // 将通用指针转换为 int64 型指针
        pi := (*int64)(p)
        // 给转换后的指针赋值
        *pi = 40
        // 结构体内容跟着改变
        fmt.Println(s)
    }

### 访问数组

package main
    
    import (
         "fmt"
         "unsafe"
    )
    
    type Foo struct {
         A int
         B int
    }
    
    func main() {
         foo := &Foo{1, 2}
         fmt.Println(foo)
    
         base := uintptr(unsafe.Pointer(foo))
         offset := unsafe.Offsetof(foo.A)
    
         ptr := unsafe.Pointer(base + offset)
         *(*int)(ptr) = 3
    
         fmt.Println(foo)
    }

### 修改其它包中的结构体私有字段

#### 方法A（指针遍历）

package main
    
    import (
        "fmt"
        "reflect"
        "strings"
        "unsafe"
    )
    
    func main() {
        // 创建一个 strings 包中的 Reader 对象
        // 它有三个私有字段：s string、i int64、prevRune int
        sr := strings.NewReader("abcdef")
        // 此时 sr 中的成员是无法修改的
        fmt.Println(sr)
        // 但是我们可以通过 unsafe 来进行修改
        // 先将其转换为通用指针
        p := unsafe.Pointer(sr)
        // 获取结构体地址
        up0 := uintptr(p)
        // 确定要修改的字段（这里不能用 unsafe.Offsetof 获取偏移量，因为是私有字段）
        if sf, ok := reflect.TypeOf(*sr).FieldByName("i"); ok {
            // 偏移到指定字段的地址
            up := up0 + sf.Offset
            // 转换为通用指针
            p = unsafe.Pointer(up)
            // 转换为相应类型的指针
            pi := (*int64)(p)
            // 对指针所指向的内容进行修改
            *pi = 3 // 修改索引
        }
        // 看看修改结果
        fmt.Println(sr)
        // 看看读出的是什么
        b, err := sr.ReadByte()
        fmt.Printf("%c, %v\n", b, err)
    }

#### 方法B（类型转换）

// 定义一个和 strings 包中的 Reader 相同的本地结构体
    type Reader struct {
        s        string
        i        int64
        prevRune int
    }
    
    func main() {
        // 创建一个 strings 包中的 Reader 对象
        sr := strings.NewReader("abcdef")
        // 此时 sr 中的成员是无法修改的
        fmt.Println(sr)
        // 我们可以通过 unsafe 来进行修改
        // 先将其转换为通用指针
        p := unsafe.Pointer(sr)
        // 再转换为本地 Reader 结构体
        pR := (*Reader)(p)
        // 这样就可以自由修改 sr 中的私有成员了
        (*pR).i = 3 // 修改索引
        // 看看修改结果
        fmt.Println(sr)
        // 看看读出的是什么
        b, err := sr.ReadByte()
        fmt.Printf("%c, %v\n", b, err)
    }

转载文章，原文链接： Golang unsafe包使用

关键字词golang unsafe

分享到：

上一篇：CGo--go语言与C语言互相调用

下一篇：go 文件操作

如需留言，请登录，没有账号？请注册

0 条评论 0 人参与

网站首页 返回列表像“草根”一样，紧贴着地面，低调的存在，冬去春来，枯荣无恙。

Golang unsafe包使用

zhou 2年前

zhou 2年前

zhou 2年前

zhou 2年前

武云 2年前

网站首页 返回列表 像“草根”一样，紧贴着地面，低调的存在，冬去春来，枯荣无恙。

Golang unsafe包使用

zhou 2年前

zhou 2年前

zhou 2年前

zhou 2年前

武云 2年前

网站首页返回列表像“草根”一样，紧贴着地面，低调的存在，冬去春来，枯荣无恙。