在 Go 中调用 C 函数的进阶教程：实现回调机制

package main

/*
#include <stdio.h>
#include <stdlib.h>

int add(int a, int b) {
    return a + b;
}
*/
import "C"
import "fmt"

func main() {
    a := C.int(10)
    b := C.int(20)
    result := C.add(a, b)
    fmt.Println("Result:", result)
}

package main

/*
#include <stdio.h>
#include <stdlib.h>

extern int goCallback(int a, int b);

int callGoCallback(int a, int b) {
    return goCallback(a, b);
}
*/
import "C"
import "fmt"

//export goCallback
func goCallback(a C.int, b C.int) C.int {
    fmt.Println("Go callback called with:", a, b)
    return a + b
}

func main() {
    a := C.int(5)
    b := C.int(7)
    result := C.callGoCallback(a, b)
    fmt.Println("Result:", result)
}

package main

/*
#include <stdio.h>
#include <stdlib.h>

typedef struct {
    int id;
    char* name;
} UserData;

extern int goProgressCB(unsigned long long current, unsigned long long total, void* userdata);

int callGoProgressCB(unsigned long long current, unsigned long long total, void* userdata) {
    return goProgressCB(current, total, userdata);
}
*/
import "C"
import "fmt"
import "unsafe"

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

type progressRequest struct {
    f ProgressHandler // The user's function pointer
    d interface{}     // The user's userdata.
}

//export goProgressCB
func goProgressCB(current C.ulonglong, total C.ulonglong, userdata unsafe.Pointer) C.int {
    // This is the function called from the C world by our expensive
    // C.somelib_get_files() function. The userdata value contains an instance
    // of *progressRequest, We unpack it and use it's values to call the
    // actual function that our user supplied.
    req := (*progressRequest)(userdata)

    // Call req.f with our parameters and the user's own userdata value.
    return C.int(req.f(uint64(current), uint64(total), req.d))
}

func GetFiles(current, total uint64, pf ProgressHandler, userdata interface{}) int {
    // Instead of calling the external C library directly, we call our C wrapper.
    // We pass it the handle and an instance of progressRequest.

    req := unsafe.Pointer(&progressRequest{pf, userdata})
    return int(C.callGoProgressCB(C.ulonglong(current), C.ulonglong(total), req))
}

func main() {
    myProgress := func(current, total uint64, userdata interface{}) int {
        fc := float64(current)
        ft := float64(total) * 0.01

        // print how far along we are.
        // eg: 500 / 1000 (50.00%)
        // For good measure, prefix it with our userdata value, which
        // we supplied as "Callbacks rock!".
        fmt.Printf("%s: %d / %d (%3.2f%%)\n", userdata.(string), current, total, fc/ft)
        return 0
    }

    GetFiles(500, 1000, myProgress, "Callbacks rock!")
}