C调用Go函数全攻略

本文详细介绍了如何在 C 代码中调用 Go 函数，利用 CGO (C Go Interface) 特性实现跨语言调用。通过代码示例，逐步讲解了如何使用 `//export` 注释标记 Go 函数，并在 C 代码中使用 `extern` 关键字声明这些函数，实现从 C 到 Go 的函数回调。文章不仅提供了简单的加法运算示例，还展示了更高级的示例，即如何在 C 函数执行过程中向 Go 应用发送进度通知，包括传递用户自定义回调函数的方法。 重点强调了 `unsafe.Pointer` 的使用注意事项、C 和 Go 之间的数据类型转换以及错误处理的重要性，旨在帮助开发者构建健壮的 C 和 Go 混合应用程序。

本文档旨在详细介绍如何在 C 代码中调用 Go 函数。由于 CGO 的复杂性，这种跨语言调用可能会让人感到困惑。本文将通过代码示例，逐步讲解如何实现从 C 到 Go 的函数回调，并提供一个更高级的示例，展示如何在 C 函数执行过程中向 Go 应用发送进度通知。

基础：从 C 调用 Go 函数

要从 C 代码调用 Go 函数，需要利用 CGO (C Go Interface) 的特性。关键在于使用 //export 注释标记 Go 函数，并使用 extern 关键字在 C 代码中声明这些函数。

示例：简单的加法运算

以下代码展示了一个简单的示例，其中 C 代码调用 Go 函数执行加法运算。

package foo

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

//export goCallbackHandler
func goCallbackHandler(a, b C.int) C.int {
    return a + b
}

// MyAdd 是一个公共函数，可以从包外部调用。
// 它将参数转发到 C.doAdd()，后者又将它们转发回
// goCallbackHandler()。这个函数执行加法运算并返回结果。
func MyAdd(a, b int) int {
   return int( C.doAdd( C.int(a), C.int(b)) )
}

在这个例子中：

1. //export goCallbackHandler 注释告诉 CGO 将 goCallbackHandler 函数导出为 C 可调用的函数。
2. extern int goCallbackHandler(int, int); 在 C 代码中声明了 goCallbackHandler 函数。
3. C.doAdd 是一个 C 函数，它调用了 Go 函数 goCallbackHandler。
4. MyAdd 是一个 Go 函数，它调用 C 函数 C.doAdd，从而间接调用 Go 函数 goCallbackHandler。

调用的顺序如下：

foo.MyAdd(a, b) ->
  C.doAdd(a, b) ->
    C.goCallbackHandler(a, b) ->
      foo.goCallbackHandler(a, b)

关键点:

• 必须使用 //export 注释标记 Go 回调函数。
• 必须在 C 代码中使用 extern 声明 Go 回调函数。
• 回调函数必须在 Go 包内部定义。

高级：传递用户自定义回调函数

为了允许用户提供自定义回调函数，可以将用户自定义的处理函数（只是一个普通的 Go 函数）作为参数传递到 C 端，作为 void*。然后，我们的包中的回调处理函数接收到这个 void*，并调用用户提供的函数。

示例：文件处理进度回调

假设有一个 C 函数从 USB 设备读取文件列表，这是一个耗时操作。为了通知应用程序进度，我们可以传递一个函数指针，该指针在读取过程中被调用。

首先，定义一个 ProgressHandler 类型：

type ProgressHandler func(current, total uint64, userdata interface{}) int

然后，编写 C 和 Go 的接口代码：

package foo

// #include <somelib.h>
// extern int goProgressCB(uint64_t current, uint64_t total, void* userdata);
//
// static int goGetFiles(some_t* handle, void* userdata) {
//    return somelib_get_files(handle, goProgressCB, userdata);
// }
import "C"
import "unsafe"

// ProgressHandler 定义用户提供的进度处理函数的签名
type ProgressHandler func(current, total uint64, userdata interface{}) int

// progressRequest 是一个内部类型，用于封装用户的回调函数和用户数据。
// 实际上，我们将把这个类型的实例发送到 C 代码。
type progressRequest struct {
   f ProgressHandler  // 用户的函数指针
   d interface{}      // 用户的用户数据
}

//export goProgressCB
func goProgressCB(current, total C.uint64_t, userdata unsafe.Pointer) C.int {
    // 这是一个从 C 代码（通过耗时的 C.somelib_get_files() 函数）调用的函数。
    // userdata 值包含 *progressRequest 的实例。我们解包它并使用它的值来调用
    // 用户提供的实际函数。
    req := (*progressRequest)(userdata)

    // 使用我们的参数和用户的用户数据值调用 req.f。
    return C.int( req.f( uint64(current), uint64(total), req.d ) )
}

// GetFiles 是一个公共函数，由用户调用，
// 它接收 C 库需要的句柄、函数指针和可选的用户定义的数据结构。
func GetFiles(h *Handle, pf ProgressHandler, userdata interface{}) int {
   // 我们不直接调用外部 C 库，而是调用我们的 C 包装器。
   // 我们将句柄和 progressRequest 的实例传递给它。

   req := unsafe.Pointer(&progressRequest{ pf, userdata })
   return int(C.goGetFiles( (*C.some_t)(h), req ))
}

在这个例子中：

1. goGetFiles 是一个 C 包装器函数，它调用实际的 C 库函数 somelib_get_files。
2. goProgressCB 是一个 Go 回调函数，它被 C 代码调用。
3. progressRequest 结构体用于封装用户的回调函数和用户数据。
4. GetFiles 是一个公共函数，用户可以使用它来调用 C 库函数并传递回调函数。

用户代码如下：

package main

import (
    "foo"
    "fmt"
)

func main() {
    handle := SomeInitStuff()

    // 调用 GetFiles。将我们的进度处理函数和一些
    // 任意用户数据（也可以是 nil）传递给它。
    ret := foo.GetFiles( handle, myProgress, "Callbacks rock!" )

    ....
}

// myProgress 是我们的进度处理函数。执行一些有用的操作，例如显示
// 进度百分比。
func myProgress(current, total uint64, userdata interface{}) int {
    fc := float64(current)
    ft := float64(total) * 0.01

    // 打印我们完成了多少。
    // 例如：500 / 1000 (50.00%)
    // 为了安全起见，在它前面加上我们的用户数据值，我们
    // 将其作为 "Callbacks rock!" 提供。
    fmt.Printf("%s: %d / %d (%3.2f%%)\n", userdata.(string), current, total, fc / ft)
    return 0
}

调用的顺序如下：

foo.GetFiles(....) ->
  C.goGetFiles(...) ->
    C.somelib_get_files(..) ->
      C.goProgressCB(...) ->
        foo.goProgressCB(...) ->
           main.myProgress(...)

注意事项：

• unsafe.Pointer 的使用需要谨慎，确保类型安全。
• C 和 Go 之间的数据类型转换需要显式进行。
• 错误处理需要仔细考虑，确保程序健壮性。

总结

从 C 代码调用 Go 函数需要理解 CGO 的工作原理，并仔细处理数据类型转换和内存管理。通过本文提供的示例，您应该能够开始构建自己的 C 和 Go 混合应用程序。记住，清晰的接口定义和仔细的错误处理是关键。

理论要掌握，实操不能落！以上关于《C调用Go函数全攻略》的详细介绍，大家都掌握了吧！如果想要继续提升自己的能力，那么就来关注golang学习网公众号吧！