// unsafe.Pointer 是一個特殊的指針類型
// 可以指向任何類型的變量，類似于C語言的void*
var p unsafe.Pointer

// 主要特性：
// - 是一個真正的指針類型
// - 參與Go的指針語義和垃圾回收
// - 可以進(jìn)行有限的類型轉(zhuǎn)換

// uintptr 是一個整數(shù)類型，大小足以存儲指針值
var addr uintptr

// 主要特性：
// - 是一個整數(shù)值，不是指針
// - 不參與Go的指針語義和垃圾回收
// - 用于存儲指針的數(shù)值表示

table
    title uintptr vs unsafe.Pointer 核心區(qū)別
    header "特性","unsafe.Pointer","uintptr"
    row "類型本質(zhì)","通用指針類型","整數(shù)類型"
    row "GC感知","? 垃圾回收器能跟蹤","? 垃圾回收器忽略"
    row "指針運(yùn)算","? 不允許直接運(yùn)算","? 允許整數(shù)運(yùn)算"
    row "安全性","相對安全","極不安全"
    row "主要用途","類型轉(zhuǎn)換橋梁","地址計(jì)算存儲"

package main

import (
    "fmt"
    "unsafe"
)

func main() {
    // 示例1：[]byte 和 string 的零拷貝轉(zhuǎn)換
    bytes := []byte("Hello, World!")
    
    // 通過unsafe.Pointer進(jìn)行安全轉(zhuǎn)換
    str := *(*string)(unsafe.Pointer(&bytes))
    fmt.Println(str) // Output: Hello, World!
    
    // 示例2：訪問結(jié)構(gòu)體未導(dǎo)出字段
    type SecretStruct struct {
        public  int
        private string // 未導(dǎo)出字段
    }
    
    s := SecretStruct{public: 42, private: "secret"}
    
    // 獲取結(jié)構(gòu)體指針，然后偏移到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 {
    // 獲取接口的實(shí)際數(shù)據(jù)指針
    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進(jìn)行指針運(yùn)算
    base := uintptr(unsafe.Pointer(&arr[0]))
    
    // 計(jì)算第二個元素的地址
    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}
    
    // 獲取第一個元素的地址并轉(zhuǎn)換為uintptr
    addr := uintptr(unsafe.Pointer(&data[0]))
    
    // 這里如果發(fā)生GC，data可能被移動，addr就失效了
    // 立即轉(zhuǎn)換回指針是安全的
    ptr := unsafe.Pointer(addr)
    value := *(*int)(ptr)
    fmt.Println(value) // Output: 1
}

package main

/*
#include <stdint.h>
// C函數(shù)示例
void process_data(uintptr_t addr, size_t len) {
    char* data = (char*)addr;
    // 處理數(shù)據(jù)...
}
*/
import "C"
import "unsafe"

func callCFunction() {
    data := []byte("hello from Go")
    
    // 將Go切片信息傳遞給C函數(shù)
    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立即轉(zhuǎn)換回unsafe.Pointer
    ptr := unsafe.Pointer(&x)
    addr := uintptr(ptr)
    
    // ? 立即轉(zhuǎn)換回去 - 安全
    newPtr := unsafe.Pointer(addr)
    value := *(*int)(newPtr)
    _ = value
    
    // ? 危險：存儲uintptr并在后續(xù)使用
    // storedAddr := addr
    // // ... 一些其他操作，可能觸發(fā)GC
    // badPtr := unsafe.Pointer(storedAddr) // 可能指向已移動的內(nèi)存
}

import (
    "reflect"
    "unsafe"
)

func reflectToPointer(v reflect.Value) unsafe.Pointer {
    // 通過反射安全獲取指針
    return unsafe.Pointer(v.UnsafeAddr())
}

func stringToBytes(s string) []byte {
    // 零拷貝string到[]byte轉(zhuǎn)換（危險但高效）
    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進(jìn)行快速序列化
func serializeFast(p *Person) []byte {
    size := unsafe.Sizeof(*p)
    bytes := make([]byte, size)
    
    // 直接將結(jié)構(gòu)體內(nèi)存復(fù)制到字節(jié)切片
    dst := unsafe.Pointer(&bytes[0])
    src := unsafe.Pointer(p)
    
    // 內(nèi)存復(fù)制（比反射快得多）
    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 {
        // 分配新內(nèi)存塊
        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)
    
    // 規(guī)則1：不要存儲uintptr到變量中延遲使用
    // bad:
    // addr := uintptr(unsafe.Pointer(&data[0]))
    // time.Sleep(time.Second) // GC可能在此期間發(fā)生
    // ptr := unsafe.Pointer(addr) // 危險！
    
    // good:
    ptr := unsafe.Pointer(&data[0])
    // 立即使用ptr，或者如果需要計(jì)算：
    base := uintptr(ptr)
    elemPtr := unsafe.Pointer(base + 8) // 立即轉(zhuǎn)換回去
    _ = elemPtr
}

func platformConsiderations() {
    // Sizeof和Offsetof的結(jié)果可能因平臺而異
    type Example struct {
        a bool    // 大小可能為1字節(jié)
        b int32   // 可能4字節(jié)對齊
        c int64   // 可能8字節(jié)對齊
    }
    
    var e Example
    fmt.Printf("Size: %d\n", unsafe.Sizeof(e))
    fmt.Printf("Offset of c: %d\n", unsafe.Offsetof(e.c))
    
    // 在編寫跨平臺代碼時要小心
}