Go CGO编程：C类型在不同包中的隔离与封装实践

cannot use &foo (type *_Ctype_int) as type *fastergo._Ctype_int in function argument

// ctuner.h
#ifndef CTUNER_H
#define CTUNER_H

typedef struct ctuner ctuner; // 不透明指针

ctuner* ctuner_new();
int ctuner_register_parameter(ctuner* t, int* parameter, int from, int to, int step);

#endif

// tuner/tuner.go
package tuner

/*
#include "ctuner.h" // 引入C头文件
#cgo LDFLAGS: -L. -lctuner // 链接C库 (假设libctuner.a或libctuner.so在当前目录)
*/
import "C" // 导入C包，所有CGO相关的类型和函数都在这里

import (
    "fmt"
    "unsafe"
)

// Tuner 是C语言ctuner结构体的Go语言表示
type Tuner struct {
    ctunerPtr uintptr // 存储C语言ctuner指针的Go表示
}

// New 创建一个新的Tuner实例，并调用C语言的ctuner_new函数
func New() *Tuner {
    // 调用C函数创建C语言的ctuner实例
    cTuner := C.ctuner_new()
    if cTuner == nil {
        // 实际应用中应返回错误
        fmt.Println("Error: Failed to create C tuner instance.")
        return nil
    }
    // 将C指针转换为uintptr存储
    return &Tuner{ctunerPtr: uintptr(unsafe.Pointer(cTuner))}
}

// RegisterParameter 注册一个参数，使用Go原生类型作为参数
func (t *Tuner) RegisterParameter(parameter *int, from, to, step int) error {
    if t.ctunerPtr == 0 {
        return fmt.Errorf("tuner instance is not initialized")
    }

    // 将Go原生类型转换为C语言类型
    // 注意：这里将Go的*int转换为*C.int需要unsafe.Pointer进行类型转换
    // 这是一个关键步骤，将Go类型指针强转为C类型指针
    rv := C.ctuner_register_parameter(
        (*C.ctuner)(unsafe.Pointer(t.ctunerPtr)), // 将uintptr转回C指针
        (*C.int)(unsafe.Pointer(parameter)),      // 将Go *int 转换为 C *int
        C.int(from),                              // Go int 转换为 C.int
        C.int(to),                                // Go int 转换为 C.int
        C.int(step),                              // Go int 转换为 C.int
    )

    if rv != 0 {
        return fmt.Errorf("failed to register parameter, C function returned: %d", rv)
    }
    return nil
}

// 实际应用中可能还需要一个Free或Close方法来释放C语言资源
// func (t *Tuner) Close() {
//     if t.ctunerPtr != 0 {
//         C.ctuner_free((*C.ctuner)(unsafe.Pointer(t.ctunerPtr)))
//         t.ctunerPtr = 0
//     }
// }

// main.go
package main

import (
    "fmt"
    "log"
    "tuner" // 导入封装好的tuner包
)

func main() {
    var foo int // 使用Go原生int类型
    foo = 3

    // 创建Tuner实例，无需关心CGO细节
    t := tuner.New()
    if t == nil {
        log.Fatalf("Failed to create tuner instance")
    }

    // 调用RegisterParameter，传入Go原生类型
    err := t.RegisterParameter(&foo, 0, 100, 1)
    if err != nil {
        log.Fatalf("Error registering parameter: %v", err)
    }

    fmt.Printf("Parameter 'foo' (value: %d) registered successfully.\n", foo)

    // 假设C函数可能会修改foo的值
    // foo = 50
    // fmt.Printf("Parameter 'foo' updated to %d.\n", foo)
}