Go语言中处理CGo非导出类型转换与unsafe.Pointer的技巧

package test

// 假设 C.C_Test 是通过 CGo 引入的 C 结构体，其 Go 映射类型为 test._Ctype_C_Test
type Test struct {
    Field *C.C_Test // 这里的 C.C_Test 实际上是 test._Ctype_C_Test 的别名
}

// 假设在另一个包中
// var ptr unsafe.Pointer // ptr 指向 C_Test 结构的内存
// t := &test.Test{Field: ptr} // 编译错误：cannot use ptr (type unsafe.Pointer) as type *test._Ctype_C_Test

package main

import (
    "fmt"
    "unsafe"
    "test" // 假设 test 包如上定义
)

// 模拟 C.C_Test 结构体的数据，实际中会从 C 库获取
type C_Test_Simulated struct {
    Value int
}

func main() {
    // 1. 模拟一个我们从外部获得的 unsafe.Pointer
    // 假设这个 ptr 指向一个 C_Test 结构体的数据
    cData := C_Test_Simulated{Value: 123}
    u := unsafe.Pointer(&cData) // 模拟从外部获取的 unsafe.Pointer

    // 2. 声明一个 test.Test 实例
    var t test.Test

    // 3. 核心步骤：双重 unsafe.Pointer 转换
    // a. unsafe.Pointer(&t.Field) 获取 t.Field 字段的内存地址，其类型为 *(*C.C_Test)
    // b. (*unsafe.Pointer)(...) 将这个地址强制转换为 *unsafe.Pointer。
    //    这意味着 p 现在是一个指向 unsafe.Pointer 的指针，而这个 unsafe.Pointer 存储的将是 t.Field 的值。
    p := (*unsafe.Pointer)(unsafe.Pointer(&t.Field))

    // c. *p = unsafe.Pointer(u) 解引用 p，并将我们外部获得的 u (unsafe.Pointer) 赋值给它。
    //    这相当于直接将 u 的值写入到 t.Field 所在的内存位置，绕过了 Go 的类型检查。
    *p = unsafe.Pointer(u)

    // 验证结果
    // 注意：由于 Field 是 *C.C_Test 类型，我们不能直接访问其内部字段（因为 C.C_Test 是非导出的）。
    // 但我们可以确认 Field 的地址已经被正确设置。
    fmt.Printf("t.Field address: %p\n", t.Field)
    fmt.Printf("u address: %p\n", u)
    fmt.Printf("Are they the same address? %t\n", t.Field == (*C.C_Test)(u)) // 验证地址是否一致

    // 如果需要访问 C_Test_Simulated 的内容，需要再次进行 unsafe.Pointer 转换
    // 假设我们知道 t.Field 实际指向 C_Test_Simulated
    retrievedCData := (*C_Test_Simulated)(unsafe.Pointer(t.Field))
    fmt.Printf("Retrieved value: %d\n", retrievedCData.Value)
}

// Assign 将 from 指向的值赋给 to 指向的内存位置
// to 和 from 都应该是 unsafe.Pointer，分别指向目标字段和源值
func Assign(to unsafe.Pointer, from unsafe.Pointer) {
    // 将 to 转换为 *unsafe.Pointer，表示 to 指向的内存将存储一个 unsafe.Pointer 值
    tptr := (*unsafe.Pointer)(to)
    // 将 from 转换为 *unsafe.Pointer，表示 from 指向的内存存储一个 unsafe.Pointer 值
    fptr := (*unsafe.Pointer)(from)
    // 解引用并将 from 指向的值赋给 to 指向的内存
    *tptr = *fptr
}

package main

import (
    "fmt"
    "unsafe"
    // "github.com/mattn/go-gtk/gtk" // 假设已导入 go-gtk 库
)

// 模拟 gtk.GtkBuilder 和 gtk.GtkWidget
type GObject struct {
    Object unsafe.Pointer // 模拟 GObject 中的 unsafe.Pointer 字段
}

type GtkWidget struct {
    Widget unsafe.Pointer // 模拟 GtkWidget 中的 *C.GtkWidget 字段
}

type GtkBuilder struct{}

func (b *GtkBuilder) GetObject(name string) *GObject {
    // 模拟 GtkBuilder 返回一个指向 C 对象的 GObject
    // 实际中，这个 unsafe.Pointer 会指向一个 C 库分配的 GtkWidget 实例
    mockCWidget := struct{ ID int }{ID: 1001} // 模拟 C 结构体
    return &GObject{Object: unsafe.Pointer(&mockCWidget)}
}

// Assign 函数定义同上
func Assign(to unsafe.Pointer, from unsafe.Pointer) {
    tptr := (*unsafe.Pointer)(to)
    fptr := (*unsafe.Pointer)(from)
    *tptr = *fptr
}

func main() {
    builder := &GtkBuilder{} // 模拟 GtkBuilder 实例

    // 假设我们需要将 GetObject 返回的 GObject 转换为 GtkWidget
    messageNameEntryWidget := GtkWidget{} // 声明目标 Go 结构体实例

    // 使用 Assign 函数进行赋值
    // unsafe.Pointer(&messageNameEntryWidget.Widget) 获取 GtkWidget 内部 Widget 字段的地址
    // unsafe.Pointer(&builder.GetObject("messageNameEntry").Object) 获取 GObject 内部 Object 字段的地址
    Assign(unsafe.Pointer(&messageNameEntryWidget.Widget),
           unsafe.Pointer(&builder.GetObject("messageNameEntry").Object))

    // 验证：虽然不能直接访问 Widget 字段的 C 类型内容，但可以验证其地址是否已设置
    fmt.Printf("messageNameEntryWidget.Widget address: %p\n", messageNameEntryWidget.Widget)
    // 如果需要，可以进一步将 messageNameEntryWidget.Widget 转换为其原始的 C 结构体类型进行操作
    retrievedCWidget := (*struct{ ID int })(messageNameEntryWidget.Widget)
    fmt.Printf("Retrieved C Widget ID: %d\n", retrievedCWidget.ID)
}