当前位置：首页 > 文章列表 > Golang > Go教程 > Go 调用 C 函数方法详解

Go 调用 C 函数方法详解

2025-08-20 10:30:31 0浏览收藏

Golang不知道大家是否熟悉？今天我将给大家介绍《Go 调用 C 函数方法详解》，这篇文章主要会讲到等等知识点，如果你在看完本篇文章后，有更好的建议或者发现哪里有问题，希望大家都能积极评论指出，谢谢！希望我们能一起加油进步！

在 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 函数。这通常涉及到以下步骤：

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

例如：

package main

// #include <stdio.h>
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。

编译和运行：

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

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

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

package main

// #include <stdio.h>
// #include <stdlib.h>
//
// 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!")
}

代码解释：