Go语言中处理非导出CGo类型与unsafe.Pointer的内存赋值技巧

// package test
package test

// #include <stdlib.h>
// typedef struct { int value; } C_Test;
import "C"

type Test struct {
    Field *C.C_Test // *C.C_Test 实际上是 test._Ctype_C_Test
}

package main

import (
    "fmt"
    "unsafe"
    "your_module/test" // 假设 test 包位于 your_module/test
)

func main() {
    // 模拟一个 unsafe.Pointer，它指向一个 C_Test 结构
    // 实际场景可能来自 C 函数返回的指针
    var cTestValue C.C_Test
    cTestPtr := unsafe.Pointer(&cTestValue) // 假设这是我们得到的 unsafe.Pointer

    // 尝试直接赋值，会失败
    // var t test.Test
    // t.Field = (*test._Ctype_C_Test)(cTestPtr) // 错误：_Ctype_C_Test 未导出
    // t.Field = cTestPtr // 错误：类型不匹配
    // t := &test.Test{Field: (*test._Ctype_C_Test)(cTestPtr)} // 同样错误
}

package main

import (
    "fmt"
    "unsafe"
    "your_module/test" // 假设 test 包位于 your_module/test
)

// #include <stdlib.h>
// typedef struct { int value; } C_Test;
import "C" // 引入 C 包，以便使用 C.C_Test 类型进行模拟

func main() {
    // 模拟一个 unsafe.Pointer，它指向一个 C_Test 结构
    // 实际场景可能来自 C 函数返回的指针
    var cTestValue C.C_Test
    cTestPtr := unsafe.Pointer(&cTestValue) // 假设这是我们得到的 unsafe.Pointer

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

    // 核心操作：双重类型转换进行内存赋值
    // 1. &t.Field: 获取 t.Field 字段的内存地址，类型是 **C.C_Test
    // 2. unsafe.Pointer(&t.Field): 将地址转换为通用指针，类型是 unsafe.Pointer
    // 3. (*unsafe.Pointer)(unsafe.Pointer(&t.Field)):
    //    将通用指针解释为一个指向 unsafe.Pointer 类型的指针，类型是 *unsafe.Pointer
    // 4. *p = cTestPtr: 通过 p 解引用，将 cTestPtr 的值写入 t.Field 所在的内存位置
    p := (*unsafe.Pointer)(unsafe.Pointer(&t.Field))
    *p = cTestPtr

    // 验证赋值是否成功
    fmt.Printf("t.Field: %v\n", t.Field)
    fmt.Printf("cTestPtr: %v\n", cTestPtr)
    // 此时 t.Field 和 cTestPtr 应该指向相同的内存地址
    fmt.Printf("t.Field address == cTestPtr address: %t\n", unsafe.Pointer(t.Field) == cTestPtr)

    // 如果需要，可以进一步验证 C 结构体中的值
    // 假设 C_Test 有一个 int 字段 'value'
    // (*C.C_Test)(unsafe.Pointer(t.Field)).value = 100
    // fmt.Printf("Value in C_Test: %d\n", (*C.C_Test)(unsafe.Pointer(t.Field)).value)
}

package main

import (
    "fmt"
    "unsafe"
    "your_module/test"
)

// #include <stdlib.h>
// typedef struct { int value; } C_Test;
import "C"

// Assign 将 'from' 指向的 unsafe.Pointer 值赋给 'to' 指向的内存位置
// 'to' 应该是一个指向目标字段的指针，例如 &myStruct.Field
// 'from' 应该是一个包含要赋值的 unsafe.Pointer 值的指针，例如 &somePtr
func Assign(to unsafe.Pointer, from unsafe.Pointer) {
    // 将 'from' 解释为一个指向 unsafe.Pointer 的指针，并解引用获取其值
    fromValue := *(*unsafe.Pointer)(from)
    // 将 'to' 解释为一个指向 unsafe.Pointer 的指针，并将其指向的内存位置设置为 fromValue
    *(*unsafe.Pointer)(to) = fromValue
}

func main() {
    var cTestValue C.C_Test
    cTestPtr := unsafe.Pointer(&cTestValue)

    var t test.Test

    // 使用 Assign 函数进行赋值
    // to: &t.Field (获取 t.Field 字段的地址)
    // from: &cTestPtr (获取 cTestPtr 变量的地址，这个地址存储了我们想要赋给 t.Field 的 unsafe.Pointer 值)
    Assign(unsafe.Pointer(&t.Field), unsafe.Pointer(&cTestPtr))

    fmt.Printf("t.Field: %v\n", t.Field)
    fmt.Printf("cTestPtr: %v\n", cTestPtr)
    fmt.Printf("t.Field address == cTestPtr address: %t\n", unsafe.Pointer(t.Field) == cTestPtr)
}

// package gtk
package gtk

// #include <gtk/gtk.h>
import "C"

type GtkWidget struct {
    Widget *C.GtkWidget // 非导出 CGo 类型
}

// 假设 GtkEntry 嵌入了 GtkWidget
type GtkEntry struct {
    GtkWidget
    // ... 其他字段
}

package main

import (
    "fmt"
    "unsafe"
    "github.com/mattn/go-gtk/gtk" // 假设 go-gtk 已安装
    "github.com/mattn/go-gtk/glib" // GObject 通常来自 glib
)

// Assign 函数如上所示，用于内存赋值
func Assign(to unsafe.Pointer, from unsafe.Pointer) {
    fromValue := *(*unsafe.Pointer)(from)
    *(*unsafe.Pointer)(to) = fromValue
}

// 模拟 GtkBuilder 和 GObject
type MockGObject struct {
    Object unsafe.Pointer // 模拟 GObject 内部的 unsafe.Pointer 字段
}

type MockGtkBuilder struct{}

func (b *MockGtkBuilder) GetObject(name string) *MockGObject {
    // 实际中这里会从 GtkBuilder 获取 C 指针
    var cWidget C.GtkWidget // 模拟一个 C.GtkWidget 实例
    fmt.Printf("Mock GtkBuilder returning object for %s, C address: %v\n", name, unsafe.Pointer(&cWidget))
    return &MockGObject{Object: unsafe.Pointer(&cWidget)}
}

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

    // 假设我们有一个名为 "messageNameEntry" 的 GtkEntry
    messageNameEntryWidget := gtk.GtkWidget{} // 创建一个 gtk.GtkWidget 实例

    // 获取 GtkBuilder 返回的 GObject 内部的 unsafe.Pointer
    gObjectPtr := builder.GetObject("messageNameEntry").Object

    // 使用 Assign 函数将 gObjectPtr 的值赋给 messageNameEntryWidget.Widget
    // to: &messageNameEntryWidget.Widget (gtk.GtkWidget 结构体中 Widget 字段的地址)
    // from: &gObjectPtr (存储了 GObject 内部 unsafe.Pointer 值的变量的地址)
    Assign(unsafe.Pointer(&messageNameEntryWidget.Widget), unsafe.Pointer(&gObjectPtr))

    fmt.Printf("Assigned GtkWidget pointer: %v\n", messageNameEntryWidget.Widget)
    fmt.Printf("Original GObject pointer: %v\n", gObjectPtr)
    fmt.Printf("Pointers match: %t\n", unsafe.Pointer(messageNameEntryWidget.Widget) == gObjectPtr)

    // 现在 messageNameEntryWidget.Widget 已经包含了正确的 C 指针
    // 我们可以将其转换为具体的 GtkEntry 类型（如果需要）
    // entry := (*gtk.GtkEntry)(unsafe.Pointer(&messageNameEntryWidget))
    // fmt.Printf("Converted to GtkEntry: %v\n", entry)
}