Go Cgo 类型隔离与跨包参数传递的最佳实践

// main package
package main

/*
#include <stdio.h>
typedef int C_int; // 假设这是某个C库的类型
*/
import "C" // main 包引入 C

import "fastergo" // 引入另一个Go包

func main() {
    var foo C.int // 在 main 包中定义 C.int
    foo = 3
    t := fastergo.Ctuner_new()
    // 尝试将 &foo 传递给 fastergo 包的函数
    fastergo.Ctuner_register_parameter(t, &foo, 0, 100, 1)
}

// fastergo package
package fastergo

/*
#include <stdio.h>
typedef int C_int; // 假设这是某个C库的类型
*/
import "C" // fastergo 包也引入 C

import "unsafe"

// 假设 Ctuner_new 和 Ctuner_register_parameter 是 Cgo 封装函数
func Ctuner_new() unsafe.Pointer {
    // ... Cgo 调用 ...
    return nil // 示例简化
}

func Ctuner_register_parameter(tuner unsafe.Pointer, parameter *C.int, from C.int, to C.int, step C.int) C.int {
    // ... Cgo 调用 ...
    return 0 // 示例简化
}

demo.go:14: 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; // 抽象的 C tuner 类型

ctuner* ctuner_new();
int ctuner_register_parameter(ctuner* t, int* parameter, int from, int to, int step);
// 更多 C 函数...

#endif

// tuner/tuner.go
package tuner

import (
    "unsafe"
)

/*
#cgo CFLAGS: -I.
#cgo LDFLAGS: -L. -lctuner // 假设有一个 libctuner.a 或 .so 文件
#include "ctuner.h"
*/
import "C" // Cgo 封装包引入 C

// Tuner 是对 C 语言 ctuner 结构体的 Go 封装
type Tuner struct {
    ctuner uintptr // 使用 uintptr 存储 C 语言指针，避免直接暴露 C.ctuner
}

// New 创建一个新的 Tuner 实例
func New() *Tuner {
    cTuner := C.ctuner_new()
    if cTuner == nil {
        // 实际应用中应返回错误
        panic("Failed to create C tuner instance")
    }
    return &Tuner{ctuner: uintptr(unsafe.Pointer(cTuner))}
}

// RegisterParameter 注册一个参数，接受 Go 原生类型
func (t *Tuner) RegisterParameter(parameter *int, from, to, step int) error {
    // 将 Go 原生类型转换为 C 语言类型
    // 注意：这里使用了 unsafe.Pointer 将 Go 指针转换为 C 指针
    rv := C.ctuner_register_parameter(
        (*C.ctuner)(unsafe.Pointer(t.ctuner)), // 将 uintptr 转换回 C.ctuner 指针
        (*C.int)(unsafe.Pointer(parameter)),    // 将 *int 转换为 *C.int
        C.int(from),                            // 将 int 转换为 C.int
        C.int(to),
        C.int(step),
    )

    if rv != 0 {
        // 实际应用中应根据 C 库的错误码返回具体的 Go 错误
        return C.GoString(C.strerror(rv)) // 假设 C 库返回错误码，这里用 strerror 示例
    }
    return nil
}

// 示例：释放 C 资源（如果需要）
func (t *Tuner) Close() {
    if t.ctuner != 0 {
        // 假设 C 库有释放资源的函数
        // C.ctuner_free((*C.ctuner)(unsafe.Pointer(t.ctuner)))
        t.ctuner = 0
    }
}

// main.go
package main

import (
    "fmt"
    "log"
    "tuner" // 引入 Cgo 封装包
)

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

    t := tuner.New() // 创建 Tuner 实例
    defer t.Close()  // 确保资源释放

    err := t.RegisterParameter(&foo, 0, 100, 1) // 传递 Go 原生类型
    if err != nil {
        log.Fatalf("Failed to register parameter: %v", err)
    }

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

    // 假设 C 函数修改了 foo 的值
    // 如果 C 函数通过指针修改了 foo，那么 Go 中的 foo 也会反映这个变化
    // 例如，如果 C 函数将 *parameter 设置为 50
    // foo 会变为 50
    // fmt.Printf("Value of foo after C interaction: %d\n", foo)
}