Go标准库unsafe适应场景

package main
import (
    "fmt"
    "unsafe"
)
func main() {
    // 不同类型指针通过Pointer转换（语法演示）
    var a int = 100
    ptrA := &a // *int类型
    // *int → Pointer → *float64（仅演示语法，数据会错乱）
    ptrUnsafe := unsafe.Pointer(ptrA)
    ptrFloat := (*float64)(ptrUnsafe)
    fmt.Printf("原int值：%d\n", a)
    fmt.Printf("强制转为float64后的值：%v（数据错乱，仅作语法演示）\n", *ptrFloat)
    // Pointer与uintptr转换（获取内存地址）
    addr := uintptr(ptrUnsafe)
    fmt.Printf("变量a的内存地址（十六进制）：%x\n", addr)
    // 合法场景：同内存布局类型转换（32位系统int与int32一致）
    var b int32 = 200
    ptrB := unsafe.Pointer(&b)
    ptrInt := (*int)(ptrB)
    fmt.Printf("int32转int后的值：%d（32位系统正常，64位需注意位数）\n", *ptrInt)
}

package main
import (
    "fmt"
    "unsafe"
)
func main() {
    var x, y int = 10, 20
    ptrX := unsafe.Pointer(&x)
    ptrY := unsafe.Pointer(&y)
    // 转换为uintptr计算地址差值（64位系统int占8字节，差值通常为8）
    addrX := uintptr(ptrX)
    addrY := uintptr(ptrY)
    fmt.Printf("x地址：%x，y地址：%x，地址差值：%d字节\n", addrX, addrY, addrY-addrX)
    // 安全写法：链式转换，避免uintptr单独存储
    safePtr := (*int)(unsafe.Pointer(uintptr(ptrX) + 8))
    fmt.Printf("x偏移8字节后的值：%d（64位系统对应y的值）\n", *safePtr)
    // 风险演示：单独存储uintptr可能产生悬空指针（不建议）
    tempAddr := addrX + 8
    tempPtr := (*int)(unsafe.Pointer(tempAddr))
    fmt.Printf("临时地址对应值：%d（结果不可靠，GC可能回收内存）\n", *tempPtr)
}

package main
import (
    "fmt"
    "unsafe"
)
func main() {
    // 基本类型大小（64位系统）
    fmt.Printf("int大小：%d字节\n", unsafe.Sizeof(int(0)))
    fmt.Printf("float64大小：%d字节\n", unsafe.Sizeof(float64(0)))
    fmt.Printf("bool大小：%d字节\n", unsafe.Sizeof(bool(false)))
    // 引用类型大小（仅存储元数据，不含底层数据）
    var str string = "hello"
    var arr []int = []int{1, 2, 3}
    var m map[string]int = make(map[string]int)
    fmt.Printf("string大小：%d字节（data指针8字节+len8字节）\n", unsafe.Sizeof(str))
    fmt.Printf("[]int大小：%d字节（data指针8+len8+cap8）\n", unsafe.Sizeof(arr))
    fmt.Printf("map大小：%d字节（仅指针，指向底层哈希表）\n", unsafe.Sizeof(m))
    // 结构体大小（受内存对齐影响）
    type Demo struct {
        a bool  // 1字节
        b int64 // 8字节
    }
    var d Demo
    fmt.Printf("Demo结构体大小：%d字节（1+7填充+8）\n", unsafe.Sizeof(d))
}

package main
import (
    "fmt"
    "unsafe"
)
// Person 包含导出字段和未导出字段
type Person struct {
    Name string // 导出字段
    age  int    // 未导出（私有）字段
    addr string // 未导出（私有）字段
}
func main() {
    p := Person{Name: "张三", age: 28, addr: "北京"}
    fmt.Printf("初始Name：%s\n", p.Name)
    // 获取私有字段偏移量
    ageOffset := unsafe.Offsetof(p.age)
    addrOffset := unsafe.Offsetof(p.addr)
    fmt.Printf("age偏移量：%d字节，addr偏移量：%d字节\n", ageOffset, addrOffset)
    // 计算私有字段地址，突破访问限制
    pPtr := unsafe.Pointer(&p)
    agePtr := (*int)(unsafe.Pointer(uintptr(pPtr) + ageOffset))
    addrPtr := (*string)(unsafe.Pointer(uintptr(pPtr) + addrOffset))
    // 读写私有字段
    fmt.Printf("原始age：%d，原始addr：%s\n", *agePtr, *addrPtr)
    *agePtr = 30
    *addrPtr = "上海"
    fmt.Printf("修改后age：%d，修改后addr：%s\n", p.age, *addrPtr)
}

package main
import (
    "fmt"
    "unsafe"
)
// 不同字段顺序的结构体，验证内存对齐对大小的影响
type Demo1 struct {
    a bool  // 对齐系数1，占1字节
    b int64 // 对齐系数8，需填充7字节
    c int32 // 对齐系数4，占4字节
}
type Demo2 struct {
    b int64 // 8字节
    c int32 // 4字节
    a bool  // 1字节，填充3字节凑整（结构体对齐系数8）
}
func main() {
    var d1 Demo1
    var d2 Demo2
    fmt.Printf("bool对齐系数：%d\n", unsafe.Alignof(d1.a))
    fmt.Printf("int64对齐系数：%d\n", unsafe.Alignof(d1.b))
    fmt.Printf("int32对齐系数：%d\n", unsafe.Alignof(d1.c))
    // 结构体大小受字段顺序影响
    fmt.Printf("Demo1大小：%d字节（1+7+8+4=20，凑整为24）\n", unsafe.Sizeof(d1))
    fmt.Printf("Demo2大小：%d字节（8+4+1+3=16，无需额外凑整）\n", unsafe.Sizeof(d2))
    // 验证字段偏移量（符合对齐规则）
    fmt.Printf("Demo1中b字段偏移量：%d字节\n", unsafe.Offsetof(d1.b))
    fmt.Printf("Demo2中a字段偏移量：%d字节\n", unsafe.Offsetof(d2.a))
}

package main
import (
    "fmt"
    "unsafe"
)
// StringToBytes 零拷贝将string转为[]byte（禁止修改返回的[]byte）
func StringToBytes(s string) []byte {
    // string结构：Data指针（8字节）+ Len（8字节）
    strHeader := (*struct {
        Data uintptr
        Len  int
    })(unsafe.Pointer(&s))
    // []byte结构：Data指针（8字节）+ Len（8字节）+ Cap（8字节）
    byteHeader := struct {
        Data uintptr
        Len  int
        Cap  int
    }{
        Data: strHeader.Data,
        Len:  strHeader.Len,
        Cap:  strHeader.Len, // cap与len一致，避免扩容修改底层数据
    }
    return *(*[]byte)(unsafe.Pointer(&byteHeader))
}
// BytesToString 零拷贝将[]byte转为string
func BytesToString(b []byte) string {
    byteHeader := (*struct {
        Data uintptr
        Len  int
        Cap  int
    })(unsafe.Pointer(&b))
    strHeader := struct {
        Data uintptr
        Len  int
    }{
        Data: byteHeader.Data,
        Len:  byteHeader.Len,
    }
    return *(*string)(unsafe.Pointer(&strHeader))
}
func main() {
    s := "hello unsafe"
    b := StringToBytes(s)
    fmt.Printf("零拷贝转换后：%s\n", b)
    // 警告：修改b会污染原始string（违背string不可变原则）
    // b[0] = 'H' // 禁止操作，可能引发程序崩溃
    b2 := []byte("hello go")
    s2 := BytesToString(b2)
    fmt.Printf("[]byte转string后：%s\n", s2)
}

package main
/*
#include <stdio.h>
#include <string.h>
// C函数：接收字符串指针并打印
void print_c_str(const char* str) {
    printf("C语言打印：%s\n", str);
}
// C函数：修改int指针指向的值
void modify_int(int* num) {
    *num = 1000;
}
*/
import "C"
import (
    "fmt"
    "unsafe"
)
func main() {
    // 1. Go字符串转C字符串
    goStr := "hello cgo"
    cStr := C.CString(goStr)
    defer C.free(unsafe.Pointer(cStr)) // 手动释放C内存，避免泄漏
    C.print_c_str(cStr)
    // 2. Go int变量地址传递给C函数
    var num int = 100
    C.modify_int((*C.int)(unsafe.Pointer(&num)))
    fmt.Printf("C函数修改后的值：%d\n", num)
    // 3. C指针转Go指针
    cNum := C.int(200)
    goNumPtr := (*int)(unsafe.Pointer(&cNum))
    fmt.Printf("C指针转Go指针后的值：%d\n", *goNumPtr)
}

package main
import (
    "fmt"
    "sync"
    "sync/atomic"
    "unsafe"
)
// Config 配置结构体
type Config struct {
    Host string
    Port int
}
var config unsafe.Pointer // 原子更新的配置指针
func main() {
    // 初始化配置
    initConfig := &Config{Host: "localhost", Port: 8080}
    atomic.StorePointer(&config, unsafe.Pointer(initConfig))
    // 并发读取配置
    var wg sync.WaitGroup
    for i := 0; i < 10; i++ {
        wg.Add(1)
        go func(idx int) {
            defer wg.Done()
            cfg := (*Config)(atomic.LoadPointer(&config))
            fmt.Printf("协程%d读取配置：%s:%d\n", idx, cfg.Host, cfg.Port)
        }(i)
    }
    // 原子更新配置
    newConfig := &Config{Host: "127.0.0.1", Port: 9090}
    atomic.StorePointer(&config, unsafe.Pointer(newConfig))
    fmt.Println("配置已原子更新")
    wg.Wait()
}

func badCase() {
    var x int = 10
    var addr uintptr = uintptr(unsafe.Pointer(&x))
    // x出作用域后被GC回收，addr成为悬空地址
    _ = addr // 后续使用addr转换为指针会非法访问
}

type BadStruct struct {
    a bool  // 1字节
    b int64 // 8字节
}
func badAlign() {
    var s BadStruct
    // 错误：手动计算偏移量1，忽略7字节填充
    bPtr := (*int64)(unsafe.Pointer(uintptr(unsafe.Pointer(&s)) + 1))
    *bPtr = 100 // 非法内存写入，可能崩溃
}