go unsafe.Pointer 使用

go unsafe.Pointer 使用

事实上，在开源代码中我们会比较少看到 unsafe.Pointer 的运用， 但是在go源码中你会发现大量的 unsafe.Pointer 的使用痕迹!

• Go语言指针的限制

  Go语言的指针 与 C语言的指针 不同，为了安全考虑Go指针做了很多限制：

  • Go的指针不能进行数学运算，无法进行指针偏移
  • 不同类型的指针不能进行相互转换
  • 不同类型的指针不能使用 == 或 != 比较
  • 不同类型的指针变量不能相互赋值

    a := 2
    b := 0.64
  
    ap := &a
    bp := &b
  
    println(ap == nil) // 指针能与nil比较
    println(ap == bp)  // 编译报错，不同类型的指针不能使用 == 或 != 比较
    ap = bp            // 编译报错，不同类型的指针变量不能相互赋值
    ap++               // 编译报错，Go 的指针不能进行数学运算
  

• Go语言的unsafe.Pointer

  前面说了，Go指针是安全的，因为做了很多限制，当然Go也有不安全的指针，就是 unsafe.Pointer。

  虽然官方并不建议大家使用，但是某些情况下 unsafe.Pointer 能让代码更高效，这也是为什么go源码大量使用 unsafe.Pointer 的原因所在。

  官方文档对 unsafe.Pointer 的描述：

  Pointer represents a pointer to an arbitrary type. There are four special operations available for type Pointer that are not available for other types:
  
    A pointer value of any type can be converted to a Pointer.
    A Pointer can be converted to a pointer value of any type.
    A uintptr can be converted to a Pointer.
    A Pointer can be converted to a uintptr.
  
    任何类型的指针都可以被转化为Pointer
    Pointer可以被转化为任何类型的指针
    uintptr可以被转化为Pointer
    Pointer可以被转化为uintptr
  

  可以看到 unsafe.Pointer 作为“桥梁”的作用，可以将使任意的类型 T1、T2 间相互转换，同时也可以通过 T -> unsafe.Pointer -> uintptr 进行偏移量运算。

• 如何使用unsafe.Pointer

  1. 利用 unsafe.Pointer 将 T1的指针 转换为 T2的指针

     ### 前提: T1的实际内存字节长度 >= T2的实际内存字节长度, 不然会导致T2的部分字节位丢失
     
     v1 := int64(1)
     v2 := float64(1)
     
     fmt.Println(reflect.TypeOf(v1)) //int64
     fmt.Println(reflect.TypeOf(v2)) //float64
     
     fmt.Println(reflect.TypeOf(&v1)) //*int64
     fmt.Println(reflect.TypeOf(&v2)) //*float64
     
     p1 := &v1
     p1 = (*int64)(unsafe.Pointer(&v2)) //使用unsafe.Pointer进行类型的转换
     
     fmt.Println(reflect.TypeOf(p1)) // *int64
     // float64(1) 的二进制为 "0011111111110000000000000000000000000000000000000000000000000000"
     // 由于是浮点数，内存中存储的二进制后几位不一定相同，因此 *p1 可能会不等于 "4607182418800018688"
     fmt.Println(*p1) // 4607182418800017408,
     

  2. 使用 unsafe.Pointer 直接操作结构体内存

     # struct
     type Obj struct {
       _v1 int32
       _v2 int64
     }
     func (o *Obj) String() {
       fmt.Printf("v1: %d, v2: %d\n", o._v1, o._v2)
     }
     
     # mian()
     func main() {
       obj := &Obj{}
     
       v1P := (*int32)(unsafe.Pointer(obj))
       *v1P = int32(12)
     
       v2P := (*int64)(unsafe.Pointer(uintptr(unsafe.Pointer(obj)) + uintptr(unsafe.Sizeof(int64(0)))))
       *v2P = int64(18)
     
       obj.String() // v1: 12, v2: 18
     }
     

     事实上上面的写法是有问题的，他忽略了struct的内存对齐问题!
     正确的写法应该是：

     # struct
     type Obj struct {
       _v1 int32
       _v2 int64
       _v3 uint8
     }
     
     func (o *Obj) String() {
       fmt.Printf("v1: %d, v2: %d, v3: %d\n", o._v1, o._v2, o._v3)
     }
     
     # mian()
     func main() {
       obj := &Obj{}
       println(unsafe.Alignof(obj))
     
       v1P := (*int32)(unsafe.Pointer(obj))
       *v1P = int32(12)
     
       v2P := (*int64)(unsafe.Pointer(uintptr(unsafe.Pointer(obj)) + unsafe.Alignof(obj)))
       *v2P = int64(18)
     
       v3P := (*uint8)(unsafe.Pointer(uintptr(unsafe.Pointer(obj)) + +unsafe.Alignof(obj) + unsafe.Alignof(obj)))
       *v3P = uint8(11)
     
       obj.String()
     }