在 Go 中调用 C 函数：构建双向桥梁的完整指南

package main

// #include <stdio.h>
// #include <stdlib.h>
//
// 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("Go: Received %d and %d from C\n", a, b)
    return a + b
}

// MyAdd is the public function, callable from outside this package.
// It forwards the parameters to C.doAdd(), which in turn forwards
// them back to goCallbackHandler(). This one performs the addition
// and yields the result.
func MyAdd(a, b int) int {
   return int( C.doAdd( C.int(a), C.int(b)) )
}

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

package main

// #include <stdio.h>
// #include <stdlib.h>
// #include <stdint.h>
//
// typedef void (*ProgressHandler)(uint64_t current, uint64_t total, void* userdata);
//
// extern int goProgressCB(uint64_t current, uint64_t total, void* userdata);
//
// static int simulate_get_files(ProgressHandler progress_cb, void* userdata) {
//     uint64_t total_files = 100;
//     for (uint64_t i = 0; i < total_files; i++) {
//         if (progress_cb != NULL) {
//             progress_cb(i, total_files, userdata);
//         }
//         // Simulate some work
//         for (int j = 0; j < 100000; j++);
//     }
//     return 0;
// }
//
// static int goGetFiles(void* userdata) {
//    return simulate_get_files((ProgressHandler)goProgressCB, userdata);
// }
import "C"
import (
    "fmt"
    "unsafe"
)

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

// progressRequest is an internal type which will pack the user's 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.uint64_t, userdata unsafe.Pointer) C.int {
    req := (*progressRequest)(userdata)
    return C.int(req.f(uint64(current), uint64(total), req.d))
}

// GetFiles is our public function, which is called by the user.
func GetFiles(pf ProgressHandler, userdata interface{}) int {
    req := unsafe.Pointer(&progressRequest{pf, userdata})
    return int(C.goGetFiles(req))
}

func main() {
    // We call GetFiles. Pass it our progress handler and some arbitrary userdata.
    ret := GetFiles(myProgress, "Callbacks rock!")

    fmt.Printf("Go: GetFiles returned: %d\n", ret)
}

// myProgress is our progress handler.
func myProgress(current, total uint64, userdata interface{}) int {
    fc := float64(current)
    ft := float64(total) * 0.01

    fmt.Printf("%s: %d / %d (%3.2f%%)\n", userdata.(string), current, total, fc/ft)
    return 0
}