Go语言中uintptr和unsafe.Pointer的区别的实现小结

// unsafe.Pointer 是一个特殊的指针类型
// 可以指向任何类型的变量，类似于C语言的void*
var p unsafe.Pointer

// 主要特性：
// - 是一个真正的指针类型
// - 参与Go的指针语义和垃圾回收
// - 可以进行有限的类型转换

// uintptr 是一个整数类型，大小足以存储指针值
var addr uintptr

// 主要特性：
// - 是一个整数值，不是指针
// - 不参与Go的指针语义和垃圾回收
// - 用于存储指针的数值表示

table
    title uintptr vs unsafe.Pointer 核心区别
    header "特性","unsafe.Pointer","uintptr"
    row "类型本质","通用指针类型","整数类型"
    row "GC感知","✅ 垃圾回收器能跟踪","❌ 垃圾回收器忽略"
    row "指针运算","❌ 不允许直接运算","✅ 允许整数运算"
    row "安全性","相对安全","极不安全"
    row "主要用途","类型转换桥梁","地址计算存储"

package main

import (
    "fmt"
    "unsafe"
)

func main() {
    // 示例1：[]byte 和 string 的零拷贝转换
    bytes := []byte("Hello, World!")
    
    // 通过unsafe.Pointer进行安全转换
    str := *(*string)(unsafe.Pointer(&bytes))
    fmt.Println(str) // Output: Hello, World!
    
    // 示例2：访问结构体未导出字段
    type SecretStruct struct {
        public  int
        private string // 未导出字段
    }
    
    s := SecretStruct{public: 42, private: "secret"}
    
    // 获取结构体指针，然后偏移到private字段
    ptr := unsafe.Pointer(&s)
    privatePtr := (*string)(unsafe.Pointer(uintptr(ptr) + unsafe.Offsetof(s.public) + 8))
    fmt.Println(*privatePtr) // Output: secret
}

func interfaceToData(i interface{}) unsafe.Pointer {
    // 获取接口的实际数据指针
    iface := (*[2]uintptr)(unsafe.Pointer(&i))
    return unsafe.Pointer(iface[1])
}

type MyStruct struct {
    Value int
}

func main() {
    s := MyStruct{Value: 100}
    var i interface{} = s
    
    dataPtr := interfaceToData(i)
    actual := (*MyStruct)(dataPtr)
    fmt.Println(actual.Value) // Output: 100
}

package main

import (
    "fmt"
    "unsafe"
)

func pointerArithmetic() {
    arr := [3]int{10, 20, 30}
    
    // 使用uintptr进行指针运算
    base := uintptr(unsafe.Pointer(&arr[0]))
    
    // 计算第二个元素的地址
    secondElemAddr := base + unsafe.Sizeof(arr[0])
    secondElem := (*int)(unsafe.Pointer(secondElemAddr))
    
    fmt.Println(*secondElem) // Output: 20
    
    // ⚠️ 危险示例：uintptr不保持引用
    dangerousExample()
}

func dangerousExample() {
    data := []int{1, 2, 3}
    
    // 获取第一个元素的地址并转换为uintptr
    addr := uintptr(unsafe.Pointer(&data[0]))
    
    // 这里如果发生GC，data可能被移动，addr就失效了
    // 立即转换回指针是安全的
    ptr := unsafe.Pointer(addr)
    value := *(*int)(ptr)
    fmt.Println(value) // Output: 1
}

package main

/*
#include <stdint.h>
// C函数示例
void process_data(uintptr_t addr, size_t len) {
    char* data = (char*)addr;
    // 处理数据...
}
*/
import "C"
import "unsafe"

func callCFunction() {
    data := []byte("hello from Go")
    
    // 将Go切片信息传递给C函数
    dataPtr := unsafe.Pointer(&data[0])
    dataLen := len(data)
    
    // 使用uintptr传递地址（CGO会自动处理）
    C.process_data(C.uintptr_t(uintptr(dataPtr)), C.size_t(dataLen))
}

func safeUsage() {
    var x int = 42
    
    // 安全：uintptr立即转换回unsafe.Pointer
    ptr := unsafe.Pointer(&x)
    addr := uintptr(ptr)
    
    // ✅ 立即转换回去 - 安全
    newPtr := unsafe.Pointer(addr)
    value := *(*int)(newPtr)
    _ = value
    
    // ❌ 危险：存储uintptr并在后续使用
    // storedAddr := addr
    // // ... 一些其他操作，可能触发GC
    // badPtr := unsafe.Pointer(storedAddr) // 可能指向已移动的内存
}

import (
    "reflect"
    "unsafe"
)

func reflectToPointer(v reflect.Value) unsafe.Pointer {
    // 通过反射安全获取指针
    return unsafe.Pointer(v.UnsafeAddr())
}

func stringToBytes(s string) []byte {
    // 零拷贝string到[]byte转换（危险但高效）
    stringHeader := (*reflect.StringHeader)(unsafe.Pointer(&s))
    sliceHeader := &reflect.SliceHeader{
        Data: stringHeader.Data,
        Len:  stringHeader.Len,
        Cap:  stringHeader.Len,
    }
    return *(*[]byte)(unsafe.Pointer(sliceHeader))
}

type Person struct {
    Name string
    Age  int
}

// 使用unsafe进行快速序列化
func serializeFast(p *Person) []byte {
    size := unsafe.Sizeof(*p)
    bytes := make([]byte, size)
    
    // 直接将结构体内存复制到字节切片
    dst := unsafe.Pointer(&bytes[0])
    src := unsafe.Pointer(p)
    
    // 内存复制（比反射快得多）
    for i := uintptr(0); i < size; i++ {
        *(*byte)(unsafe.Pointer(uintptr(dst) + i)) = 
            *(*byte)(unsafe.Pointer(uintptr(src) + i))
    }
    
    return bytes
}

type MemoryPool struct {
    blockSize uintptr
    blocks    []unsafe.Pointer
}

func (p *MemoryPool) Alloc() unsafe.Pointer {
    if len(p.blocks) == 0 {
        // 分配新内存块
        block := make([]byte, p.blockSize)
        return unsafe.Pointer(&block[0])
    }
    
    // 从池中取出块
    block := p.blocks[len(p.blocks)-1]
    p.blocks = p.blocks[:len(p.blocks)-1]
    return block
}

func gcSafetyRules() {
    data := make([]int, 100)
    
    // 规则1：不要存储uintptr到变量中延迟使用
    // bad:
    // addr := uintptr(unsafe.Pointer(&data[0]))
    // time.Sleep(time.Second) // GC可能在此期间发生
    // ptr := unsafe.Pointer(addr) // 危险！
    
    // good:
    ptr := unsafe.Pointer(&data[0])
    // 立即使用ptr，或者如果需要计算：
    base := uintptr(ptr)
    elemPtr := unsafe.Pointer(base + 8) // 立即转换回去
    _ = elemPtr
}

func platformConsiderations() {
    // Sizeof和Offsetof的结果可能因平台而异
    type Example struct {
        a bool    // 大小可能为1字节
        b int32   // 可能4字节对齐
        c int64   // 可能8字节对齐
    }
    
    var e Example
    fmt.Printf("Size: %d\n", unsafe.Sizeof(e))
    fmt.Printf("Offset of c: %d\n", unsafe.Offsetof(e.c))
    
    // 在编写跨平台代码时要小心
}