package main
import (
    "fmt"
    "unsafe"
)
func main() {
    // 不同類型指針通過Pointer轉(zhuǎn)換（語法演示）
    var a int = 100
    ptrA := &a // *int類型
    // *int → Pointer → *float64（僅演示語法，數(shù)據(jù)會錯亂）
    ptrUnsafe := unsafe.Pointer(ptrA)
    ptrFloat := (*float64)(ptrUnsafe)
    fmt.Printf("原int值：%d\n", a)
    fmt.Printf("強(qiáng)制轉(zhuǎn)為float64后的值：%v（數(shù)據(jù)錯亂，僅作語法演示）\n", *ptrFloat)
    // Pointer與uintptr轉(zhuǎn)換（獲取內(nèi)存地址）
    addr := uintptr(ptrUnsafe)
    fmt.Printf("變量a的內(nèi)存地址（十六進(jìn)制）：%x\n", addr)
    // 合法場景：同內(nèi)存布局類型轉(zhuǎn)換（32位系統(tǒng)int與int32一致）
    var b int32 = 200
    ptrB := unsafe.Pointer(&b)
    ptrInt := (*int)(ptrB)
    fmt.Printf("int32轉(zhuǎn)int后的值：%d（32位系統(tǒng)正常，64位需注意位數(shù)）\n", *ptrInt)
}

package main
import (
    "fmt"
    "unsafe"
)
func main() {
    var x, y int = 10, 20
    ptrX := unsafe.Pointer(&x)
    ptrY := unsafe.Pointer(&y)
    // 轉(zhuǎn)換為uintptr計算地址差值（64位系統(tǒng)int占8字節(jié)，差值通常為8）
    addrX := uintptr(ptrX)
    addrY := uintptr(ptrY)
    fmt.Printf("x地址：%x，y地址：%x，地址差值：%d字節(jié)\n", addrX, addrY, addrY-addrX)
    // 安全寫法：鏈?zhǔn)睫D(zhuǎn)換，避免uintptr單獨存儲
    safePtr := (*int)(unsafe.Pointer(uintptr(ptrX) + 8))
    fmt.Printf("x偏移8字節(jié)后的值：%d（64位系統(tǒng)對應(yīng)y的值）\n", *safePtr)
    // 風(fēng)險演示：單獨存儲uintptr可能產(chǎn)生懸空指針（不建議）
    tempAddr := addrX + 8
    tempPtr := (*int)(unsafe.Pointer(tempAddr))
    fmt.Printf("臨時地址對應(yīng)值：%d（結(jié)果不可靠，GC可能回收內(nèi)存）\n", *tempPtr)
}

package main
import (
    "fmt"
    "unsafe"
)
func main() {
    // 基本類型大?。?4位系統(tǒng)）
    fmt.Printf("int大?。?d字節(jié)\n", unsafe.Sizeof(int(0)))
    fmt.Printf("float64大小：%d字節(jié)\n", unsafe.Sizeof(float64(0)))
    fmt.Printf("bool大?。?d字節(jié)\n", unsafe.Sizeof(bool(false)))
    // 引用類型大?。▋H存儲元數(shù)據(jù)，不含底層數(shù)據(jù)）
    var str string = "hello"
    var arr []int = []int{1, 2, 3}
    var m map[string]int = make(map[string]int)
    fmt.Printf("string大小：%d字節(jié)（data指針8字節(jié)+len8字節(jié)）\n", unsafe.Sizeof(str))
    fmt.Printf("[]int大?。?d字節(jié)（data指針8+len8+cap8）\n", unsafe.Sizeof(arr))
    fmt.Printf("map大?。?d字節(jié)（僅指針，指向底層哈希表）\n", unsafe.Sizeof(m))
    // 結(jié)構(gòu)體大?。ㄊ軆?nèi)存對齊影響）
    type Demo struct {
        a bool  // 1字節(jié)
        b int64 // 8字節(jié)
    }
    var d Demo
    fmt.Printf("Demo結(jié)構(gòu)體大小：%d字節(jié)（1+7填充+8）\n", unsafe.Sizeof(d))
}

package main
import (
    "fmt"
    "unsafe"
)
// Person 包含導(dǎo)出字段和未導(dǎo)出字段
type Person struct {
    Name string // 導(dǎo)出字段
    age  int    // 未導(dǎo)出（私有）字段
    addr string // 未導(dǎo)出（私有）字段
}
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字節(jié)，addr偏移量：%d字節(jié)\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"
)
// 不同字段順序的結(jié)構(gòu)體，驗證內(nèi)存對齊對大小的影響
type Demo1 struct {
    a bool  // 對齊系數(shù)1，占1字節(jié)
    b int64 // 對齊系數(shù)8，需填充7字節(jié)
    c int32 // 對齊系數(shù)4，占4字節(jié)
}
type Demo2 struct {
    b int64 // 8字節(jié)
    c int32 // 4字節(jié)
    a bool  // 1字節(jié)，填充3字節(jié)湊整（結(jié)構(gòu)體對齊系數(shù)8）
}
func main() {
    var d1 Demo1
    var d2 Demo2
    fmt.Printf("bool對齊系數(shù)：%d\n", unsafe.Alignof(d1.a))
    fmt.Printf("int64對齊系數(shù)：%d\n", unsafe.Alignof(d1.b))
    fmt.Printf("int32對齊系數(shù)：%d\n", unsafe.Alignof(d1.c))
    // 結(jié)構(gòu)體大小受字段順序影響
    fmt.Printf("Demo1大?。?d字節(jié)（1+7+8+4=20，湊整為24）\n", unsafe.Sizeof(d1))
    fmt.Printf("Demo2大?。?d字節(jié)（8+4+1+3=16，無需額外湊整）\n", unsafe.Sizeof(d2))
    // 驗證字段偏移量（符合對齊規(guī)則）
    fmt.Printf("Demo1中b字段偏移量：%d字節(jié)\n", unsafe.Offsetof(d1.b))
    fmt.Printf("Demo2中a字段偏移量：%d字節(jié)\n", unsafe.Offsetof(d2.a))
}

package main
import (
    "fmt"
    "unsafe"
)
// StringToBytes 零拷貝將string轉(zhuǎn)為[]byte（禁止修改返回的[]byte）
func StringToBytes(s string) []byte {
    // string結(jié)構(gòu)：Data指針（8字節(jié)）+ Len（8字節(jié)）
    strHeader := (*struct {
        Data uintptr
        Len  int
    })(unsafe.Pointer(&s))
    // []byte結(jié)構(gòu)：Data指針（8字節(jié)）+ Len（8字節(jié)）+ Cap（8字節(jié)）
    byteHeader := struct {
        Data uintptr
        Len  int
        Cap  int
    }{
        Data: strHeader.Data,
        Len:  strHeader.Len,
        Cap:  strHeader.Len, // cap與len一致，避免擴(kuò)容修改底層數(shù)據(jù)
    }
    return *(*[]byte)(unsafe.Pointer(&byteHeader))
}
// BytesToString 零拷貝將[]byte轉(zhuǎn)為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("零拷貝轉(zhuǎn)換后：%s\n", b)
    // 警告：修改b會污染原始string（違背string不可變原則）
    // b[0] = 'H' // 禁止操作，可能引發(fā)程序崩潰
    b2 := []byte("hello go")
    s2 := BytesToString(b2)
    fmt.Printf("[]byte轉(zhuǎn)string后：%s\n", s2)
}

package main
/*
#include <stdio.h>
#include <string.h>
// C函數(shù)：接收字符串指針并打印
void print_c_str(const char* str) {
    printf("C語言打?。?s\n", str);
}
// C函數(shù)：修改int指針指向的值
void modify_int(int* num) {
    *num = 1000;
}
*/
import "C"
import (
    "fmt"
    "unsafe"
)
func main() {
    // 1. Go字符串轉(zhuǎn)C字符串
    goStr := "hello cgo"
    cStr := C.CString(goStr)
    defer C.free(unsafe.Pointer(cStr)) // 手動釋放C內(nèi)存，避免泄漏
    C.print_c_str(cStr)
    // 2. Go int變量地址傳遞給C函數(shù)
    var num int = 100
    C.modify_int((*C.int)(unsafe.Pointer(&num)))
    fmt.Printf("C函數(shù)修改后的值：%d\n", num)
    // 3. C指針轉(zhuǎn)Go指針
    cNum := C.int(200)
    goNumPtr := (*int)(unsafe.Pointer(&cNum))
    fmt.Printf("C指針轉(zhuǎn)Go指針后的值：%d\n", *goNumPtr)
}

package main
import (
    "fmt"
    "sync"
    "sync/atomic"
    "unsafe"
)
// Config 配置結(jié)構(gòu)體
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))
    // 并發(fā)讀取配置
    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("協(xié)程%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 // 后續(xù)使用addr轉(zhuǎn)換為指針會非法訪問
}

type BadStruct struct {
    a bool  // 1字節(jié)
    b int64 // 8字節(jié)
}
func badAlign() {
    var s BadStruct
    // 錯誤：手動計算偏移量1，忽略7字節(jié)填充
    bPtr := (*int64)(unsafe.Pointer(uintptr(unsafe.Pointer(&s)) + 1))
    *bPtr = 100 // 非法內(nèi)存寫入，可能崩潰
}