如何将C函数指针转为Go接口并通过reflect.Value.Call()调用？

这个需求完全可行，核心是借助Go的cgo特性和unsafe包完成C函数指针到Go可调用函数值的转换，再存入你的函数注册表。以下是具体实现步骤和代码示例：

核心思路 #

C函数指针无法直接转换为Go的interface{}，需要通过unsafe.Pointer传递指针，再在Go侧根据预定义的函数签名，用reflect.MakeFunc构造出可被reflect调用的Go函数值，最终存入map[string]interface{}。

1. Go侧动态库实现（lib.go） #

package main

import "C"
import (
	"reflect"
	"unsafe"
)

// 全局函数注册表
var funcMap = make(map[string]interface{})

//export RegisterCFunc
// 注册C函数：name为函数名，fn为C函数指针，sig为函数签名的reflect.Type指针
func RegisterCFunc(name *C.char, fn unsafe.Pointer, sig uintptr) {
	funcName := C.GoString(name)
	// 将uintptr转回reflect.Type
	funcType := (*reflect.rtype)(unsafe.Pointer(sig))

	// 用reflect.MakeFunc创建封装C函数调用的Go函数
	wrapper := reflect.MakeFunc(funcType, func(args []reflect.Value) []reflect.Value {
		// 转换Go参数为C可识别的指针数组
		cArgs := make([]unsafe.Pointer, len(args))
		for i, arg := range args {
			cArgs[i] = unsafe.Pointer(arg.UnsafeAddr())
		}

		// 调用C函数
		fnValue := reflect.ValueOf(fn)
		result := fnValue.Call(cArgs)

		// 转换C返回值为Go值并返回
		goResults := make([]reflect.Value, len(result))
		copy(goResults, result)
		return goResults
	}).Interface()

	funcMap[funcName] = wrapper
}

//export CallFunc
// 动态调用注册的函数：name为函数名，args为参数指针数组，argCount为参数数量，ret为返回值存储地址
func CallFunc(name *C.char, args unsafe.Pointer, argCount C.int, ret unsafe.Pointer) {
	funcName := C.GoString(name)
	fn, ok := funcMap[funcName]
	if !ok {
		return
	}

	// 解析参数
	fnType := reflect.TypeOf(fn)
	goArgs := make([]reflect.Value, int(argCount))
	argSlice := (*[1 << 30]unsafe.Pointer)(args)[:int(argCount):int(argCount)]
	for i := 0; i < int(argCount); i++ {
		argType := fnType.In(i)
		goArgs[i] = reflect.New(argType).Elem()
		// 从C指针拷贝数据到Go变量
		reflect.Copy(goArgs[i].Addr(), reflect.ValueOf(argSlice[i]).Elem())
	}

	// 调用函数
	results := reflect.ValueOf(fn).Call(goArgs)

	// 处理返回值（仅处理单个返回值的情况，多返回值可扩展）
	if len(results) > 0 && ret != nil {
		retType := fnType.Out(0)
		retVal := reflect.New(retType).Elem()
		retVal.Set(results[0])
		// 将Go返回值拷贝到C指针
		reflect.Copy(reflect.ValueOf(ret).Elem(), retVal.Addr())
	}
}

//export GetAddFuncType
// 导出add函数的签名类型，供C侧传递
func GetAddFuncType() uintptr {
	type AddFunc func(int, int) int
	return uintptr(unsafe.Pointer(reflect.TypeOf((*AddFunc)(nil)).Elem()))
}

func main() {} // 必须保留空main函数，否则无法编译为C共享库

2. C侧调用代码（main.c） #

#include <stdio.h>
#include <stdint.h>

// 声明Go动态库导出的函数
extern void RegisterCFunc(const char* name, void* fn, uintptr_t sig);
extern void CallFunc(const char* name, void** args, int argCount, void* ret);
extern uintptr_t GetAddFuncType();

// 定义待注册的C函数示例
int add(int a, int b) {
    return a + b;
}

int main() {
    // 注册C函数add到Go的函数注册表
    RegisterCFunc("add", (void*)add, GetAddFuncType());

    // 准备调用参数
    int arg1 = 10, arg2 = 20;
    void* args[] = {&arg1, &arg2};
    int ret;

    // 调用Go侧的CallFunc执行注册的add函数
    CallFunc("add", args, 2, &ret);

    printf("Call C function add(10,20) result: %d\n", ret); // 输出30
    return 0;
}

3. 编译与运行步骤 #

1. 编译Go动态库：

go build -o libadd.so -buildmode=c-shared lib.go

2. 编译C程序：

gcc main.c -o main -L. -ladd

3. 运行（Linux下需指定动态库路径）：

LD_LIBRARY_PATH=. ./main

关键注意事项 #

• 类型严格匹配：C函数的签名必须和Go侧定义的函数类型完全一致，否则会触发内存错误。
• unsafe包的使用：这里用到unsafe.Pointer做指针转换，属于底层操作，必须确保类型转换的正确性。
• 复杂类型处理：如果需要传递结构体、字符串等复杂类型，需手动处理内存拷贝，避免跨语言内存管理冲突。
• 调用约定：cgo默认使用C语言调用约定，若C函数使用特殊约定（如stdcall），需额外适配。

内容的提问来源于stack exchange，提问作者lukz