Go语言动态加载C库与FFI实现策略解析

// dynamic_loader.c
#include <dlfcn.h>
#include <stdio.h>

// 定义一个C函数，用于动态加载库并调用其中的函数
// 实际应用中需要更复杂的参数处理和错误检查
typedef int (*MyFuncType)(int, int);

void* load_and_call(const char* lib_path, const char* func_name, int a, int b) {
    void* handle = dlopen(lib_path, RTLD_LAZY);
    if (!handle) {
        fprintf(stderr, "Error loading library: %s\n", dlerror());
        return NULL;
    }

    MyFuncType func = (MyFuncType)dlsym(handle, func_name);
    if (!func) {
        fprintf(stderr, "Error finding function: %s\n", dlerror());
        dlclose(handle);
        return NULL;
    }

    int result = func(a, b);
    dlclose(handle);

    // 返回结果的指针，或者直接返回结果值，取决于函数签名
    // 这里为了演示，我们假设返回一个 int 值
    int* res_ptr = (int*)malloc(sizeof(int));
    *res_ptr = result;
    return res_ptr;
}

// main.go
package main

/*
#cgo LDFLAGS: -ldl
#include <stdlib.h> // For C.free
#include "dynamic_loader.h" // 包含上面定义的C函数声明
*/
import "C"
import (
    "fmt"
    "unsafe"
)

// dynamic_loader.h (需要手动创建，包含C函数的声明)
// #ifndef DYNAMIC_LOADER_H
// #define DYNAMIC_LOADER_H
// #include <stdlib.h> // For malloc/free
// void* load_and_call(const char* lib_path, const char* func_name, int a, int b);
// #endif

func main() {
    libPath := C.CString("./my_library.so") // 假设有一个共享库
    funcName := C.CString("Add")           // 假设库中有一个 Add(int, int) 函数

    // 调用C函数进行动态加载和调用
    cResultPtr := C.load_and_call(libPath, funcName, C.int(10), C.int(20))
    if cResultPtr == nil {
        fmt.Println("动态调用失败。")
        return
    }

    // 将C返回的指针转换为Go类型
    result := *(*C.int)(cResultPtr)
    fmt.Printf("动态调用 Add(10, 20) 结果: %d\n", result)

    // 释放C字符串和C分配的内存
    C.free(unsafe.Pointer(libPath))
    C.free(unsafe.Pointer(funcName))
    C.free(cResultPtr)
}

package main

import (
    "fmt"
    "syscall"
    "unsafe"
)

// 假设我们有一个简单的C函数在my_library.dll中
// C函数签名: int Add(int a, int b);
// 编译为DLL:
// // my_library.c
// #include <windows.h>
// #ifdef __cplusplus
// extern "C" {
// #endif
// __declspec(dllexport) int Add(int a, int b) {
//     return a + b;
// }
// #ifdef __cplusplus
// }
// #endif
// // 编译命令: gcc -shared -o my_library.dll my_library.c
// 确保my_library.dll与Go程序在同一目录下

func main() {
    dllName := "my_library.dll"
    funcName := "Add"

    // 1. 加载DLL
    dll, err := syscall.LoadLibrary(dllName)
    if err != nil {
        fmt.Printf("加载DLL '%s' 失败: %v\n", dllName, err)
        return
    }
    defer syscall.FreeLibrary(dll) // 确保DLL在程序退出时被卸载

    // 2. 获取函数地址
    proc, err := syscall.GetProcAddress(dll, funcName)
    if err != nil {
        fmt.Printf("获取函数 '%s' 地址失败: %v\n", funcName, err)
        return
    }

    // 3. 调用函数
    // syscall.SyscallN 是一个低级别调用，适用于多个参数的函数。
    // 参数需要转换为 uintptr 类型。
    // 返回值也是 uintptr，需要转换回 Go 类型。
    // 函数签名: int Add(int a, int b)
    // SyscallN(proc uintptr, nargs uintptr, a1, a2, ..., aN uintptr) (r1, r2 uintptr, err syscall.Errno)
    // nargs 是参数的数量
    a := 10
    b := 20

    // SyscallN 的第三个返回值是错误码，通常在 r1 为 0 且 r2 不为 0 时表示错误。
    // 但对于大多数简单的C函数，可以直接忽略 r2 和 err。
    ret, _, _ := syscall.SyscallN(proc, uintptr(2), uintptr(a), uintptr(b))

    result := int(ret)
    fmt.Printf("动态调用 %s(%d, %d) 结果: %d\n", funcName, a, b, result)

    // 注意：
    // - 对于返回字符串或复杂结构体的C函数，需要更复杂的内存管理和类型转换，通常涉及 unsafe.Pointer。
    // - SyscallN的参数数量和类型必须与C函数的实际签名严格匹配，否则可能导致程序崩溃或不可预测的行为。
    // - 错误处理需要根据实际C函数的返回值和错误码进行。
}