Go 调用 C 函数方法详解

本文详细介绍了如何在 Go 语言中调用 C 函数，特别是如何处理 C 函数回调 Go 函数的情况。通过具体的代码示例，展示了如何使用 cgo 工具以及 //export 指令，实现 Go 代码与 C 代码的互操作，并提供了一种通用的解决方案，允许用户自定义回调函数，从而在 C 代码执行过程中将进度信息传递回 Go 程序。

Go 调用 C 函数及 C 回调 Go 函数详解

Go 语言提供了 cgo 工具，允许 Go 代码调用 C 代码，这在需要利用现有 C 库或进行底层系统编程时非常有用。本文将重点介绍如何从 C 代码中回调 Go 函数，并提供详细的示例代码和步骤说明。

基础：Go 调用 C 函数

首先，让我们回顾一下 Go 如何调用 C 函数。这通常涉及到以下步骤：

1. 导入 "C" 包： 在 Go 代码中导入 C 包，这是 cgo 的入口。
2. 包含 C 头文件： 使用 // #include 注释在 Go 代码中包含 C 头文件。
3. 调用 C 函数： 使用 C.functionName() 语法调用 C 函数。

例如：

package main

// #include 
import "C"

func main() {
    C.puts(C.CString("Hello, C world!"))
}

关键：C 回调 Go 函数

从 C 代码回调 Go 函数稍微复杂一些，但 cgo 提供了机制来实现这一目标。关键在于使用 //export 指令标记 Go 函数，并使用 extern 关键字在 C 代码中声明该函数。

示例 1：简单的加法回调

以下是一个简单的示例，演示了如何从 C 代码回调一个 Go 函数，该函数执行加法运算：

package main

// extern int goCallbackHandler(int, int);
//
// static int doAdd(int a, int b) {
//     return goCallbackHandler(a, b);
// }
import "C"
import "fmt"

//export goCallbackHandler
func goCallbackHandler(a, b C.int) C.int {
    fmt.Printf("goCallbackHandler called with a=%d, b=%d\n", a, b)
    return a + b
}

// MyAdd is a Go function that calls a C function which in turn calls back to Go.
func MyAdd(a, b int) int {
    return int(C.doAdd(C.int(a), C.int(b)))
}

func main() {
    result := MyAdd(5, 3)
    fmt.Printf("Result of MyAdd(5, 3): %d\n", result)
}

代码解释：

• //extern int goCallbackHandler(int, int);：在 import "C" 之前，使用 extern 声明 C 代码中将要调用的 Go 函数。
• // static int doAdd(int a, int b) { return goCallbackHandler(a, b); }：定义了一个 C 函数 doAdd，它调用 goCallbackHandler。
• //export goCallbackHandler：使用 //export 指令标记 Go 函数 goCallbackHandler，使其可以被 C 代码调用。
• MyAdd 函数是 Go 中调用 C 代码的入口。它调用 C 函数 doAdd，而 doAdd 又回调 Go 函数 goCallbackHandler。

编译和运行：

1. 将代码保存为 main.go。
2. 执行 go build。
3. 运行生成的可执行文件。

示例 2：带用户自定义数据的回调

更复杂的情况是，我们需要将用户自定义的数据传递给回调函数。这可以通过将数据打包到 void* 指针中来实现。

package main

// #include 
// #include 
//
// typedef void (*progress_callback)(unsigned long long current, unsigned long long total, void* userdata);
//
// extern void goProgressCB(unsigned long long current, unsigned long long total, void* userdata);
//
// static void simulate_progress(progress_callback cb, void* userdata) {
//     unsigned long long total = 100;
//     for (unsigned long long i = 0; i <= total; i++) {
//         cb(i, total, userdata);
//     }
// }
import "C"
import (
    "fmt"
    "unsafe"
)

// ProgressHandler defines the signature of our user's progress handler
type ProgressHandler func(current, total uint64, userdata interface{})

// progressRequest is an internal type which will pack the users callback function and userdata.
type progressRequest struct {
    f ProgressHandler // The user's function pointer
    d interface{}     // The user's userdata.
}

//export goProgressCB
func goProgressCB(current, total C.ulonglong, userdata unsafe.Pointer) {
    req := (*progressRequest)(userdata)
    req.f(uint64(current), uint64(total), req.d)
}

// SimulateProgress simulates a C function that reports progress using a callback.
func SimulateProgress(pf ProgressHandler, userdata interface{}) {
    req := &progressRequest{pf, userdata}
    C.simulate_progress(C.progress_callback(C.goProgressCB), unsafe.Pointer(req))
}

func main() {
    myProgress := func(current, total uint64, userdata interface{}) {
        fmt.Printf("Progress: %d/%d, Userdata: %v\n", current, total, userdata)
    }

    SimulateProgress(myProgress, "Hello from Go!")
}

代码解释：

• C 代码定义了一个 progress_callback 类型，它是一个函数指针，接受当前进度、总进度和用户数据。
• simulate_progress 函数模拟一个 C 函数，该函数通过调用回调函数来报告进度。
• Go 代码定义了一个 ProgressHandler 类型，它与 C 代码中的 progress_callback 类型对应。
• progressRequest 结构体用于将 Go 回调函数和用户数据打包在一起。
• goProgressCB 函数是实际的回调函数，它从 userdata 中提取 progressRequest，并调用 Go 回调函数。
• SimulateProgress 函数是 Go 中调用 C 代码的入口。

注意事项：

• 内存管理： 在 C 和 Go 之间传递数据时，需要特别注意内存管理。确保在不再需要数据时释放内存。
• 类型转换： 在 C 和 Go 之间传递数据时，需要进行类型转换。使用 C.int()、C.CString() 等函数进行转换。
• unsafe 包： 使用 unsafe 包需要谨慎，因为它可能会导致程序崩溃或产生未定义的行为。
• //export 指令： 必须在 //export 指令之前留空一行。

总结：

通过 cgo，我们可以方便地在 Go 代码中调用 C 代码，并且可以从 C 代码回调 Go 函数。这使得我们可以利用现有的 C 库，并使用 Go 语言的优势来构建高性能的应用程序。 理解 //export 的用法以及数据类型转换是关键。 此外，需要特别注意内存管理，避免内存泄漏。