将Go本地函数转换为C语言"回调"的方法

在Go中直接传递局部函数作为C回调是有限制的，但可以通过C函数指针包装器实现。以下是解决方案：

package main

/*
typedef int (*callback)(int, int);
void test(callback c) { c(1, 2); }
*/
import "C"
import (
	"fmt"
	"sync"
)

var (
	callbackMu sync.Mutex
	callbackID uintptr
	callbacks  = make(map[uintptr]func(C.int, C.int) C.int)
)

//export goCallbackBridge
func goCallbackBridge(id C.uintptr_t, a, b C.int) C.int {
	callbackMu.Lock()
	cb := callbacks[uintptr(id)]
	callbackMu.Unlock()
	
	if cb != nil {
		return cb(a, b)
	}
	return 0
}

func registerCallback(fn func(C.int, C.int) C.int) C.callback {
	callbackMu.Lock()
	defer callbackMu.Unlock()
	
	id := callbackID
	callbackID++
	callbacks[id] = fn
	
	return C.callback(C.callbackBridge(C.uintptr_t(id)))
}

func unregisterCallback(id uintptr) {
	callbackMu.Lock()
	defer callbackMu.Unlock()
	delete(callbacks, id)
}

func main() {
	// 定义局部回调函数
	cb := func(a, b C.int) C.int {
		fmt.Printf("Go callback! %d, %d\n", a, b)
		return a + b
	}
	
	// 注册并获取C回调
	cCallback := registerCallback(cb)
	defer unregisterCallback(0) // 实际使用时需要保存ID
	
	// 调用C函数
	C.test(cCallback)
}

需要配套的C桥接代码（在单独的C文件或cgo注释中）：

#include <stdint.h>

extern int goCallbackBridge(uintptr_t id, int a, int b);

static int callbackBridge(uintptr_t id, int a, int b) {
    return goCallbackBridge(id, a, b);
}

如果必须完全在Go中实现，可以使用全局映射方案：

package main

/*
typedef int (*callback)(int, int);
void test(callback c) { c(1, 2); }

// 静态桥接函数
static int bridge(uintptr_t id, int a, int b);
*/
import "C"
import (
	"fmt"
	"unsafe"
)

// 使用sync.Map处理并发
var callbackStore = struct {
	sync.RWMutex
	m map[uintptr]func(C.int, C.int) C.int
}{m: make(map[uintptr]func(C.int, C.int) C.int)}

//export goCallbackHandler
func goCallbackHandler(id C.uintptr_t, a, b C.int) C.int {
	callbackStore.RLock()
	cb := callbackStore.m[uintptr(id)]
	callbackStore.RUnlock()
	
	if cb != nil {
		return cb(a, b)
	}
	return -1
}

func main() {
	// 创建局部函数
	localFunc := func(x, y C.int) C.int {
		fmt.Printf("Local callback: %d + %d = %d\n", x, y, x+y)
		return x * y
	}
	
	// 生成唯一ID并存储
	funcID := uintptr(unsafe.Pointer(&localFunc))
	callbackStore.Lock()
	callbackStore.m[funcID] = localFunc
	callbackStore.Unlock()
	
	// 清理函数
	defer func() {
		callbackStore.Lock()
		delete(callbackStore.m, funcID)
		callbackStore.Unlock()
	}()
	
	// 调用C函数
	C.test(C.callback(unsafe.Pointer(C.bridge(C.uintptr_t(funcID)))))
}

C桥接部分：

#include <stdint.h>

extern int goCallbackHandler(uintptr_t id, int a, int b);

static int bridge(uintptr_t id, int a, int b) {
    return goCallbackHandler(id, a, b);
}

关键点：

1. 使用C桥接函数作为静态中间层
2. 通过ID映射Go回调函数
3. 处理内存管理和并发安全
4. 局部函数通过闭包捕获上下文，但C只能调用静态函数

这种方法允许在Go中使用局部函数作为C回调，同时保持类型安全和内存安全。