编组无法从 Go 访问的 C 对象

有一些 C 对象，例如联合体、包含位域的结构体以及其对齐方式与 Go 的 ABI 不同的结构体，无法从 Go 访问。其中一些结构无法更改为可从 Go 代码访问，因为它们是现有库的 API 的一部分。

因此，要将这些对象编组到 Go 结构中，我们无法真正使用 Go 代码。相反，我们必须用 C 编写编组代码。这工作得很好，但我还没有找到一种可行的方法来定义对 Go 代码中定义的类型进行操作的 C 函数。现在，我正在定义要在 C 端编组的数据类型，并在我的 Go 代码中使用这些数据类型。

如果我想在 Go 代码中将编组类型公开为 API，这真的很糟糕，因为我无法将 C 类型公开为包接口的一部分。我当前的方法是将已经编组的对象重新编组为 Go 代码中定义的类型。

有没有更优雅的方式来做我想做的事情，即将无法从 Go 代码访问的 C 结构编组为 Go 代码中定义的数据类型?

根据评论部分的要求，这里是无法从 Go 访问的 C 对象的集合。

#include <complex.h>
#include <stdbool.h>

union foo {
    int i;
    float f;
};

struct bar {
    bool x:1;
    unsigned int y:3;
    unsigned int z:4;
};

struct baz {
    float f;
    complex float c;
};

#pragma pack 1
struct quux {
    char c;
    short s;
    int i;
};

标准套餐encoding/binary可用于操作原始 C 结构。 您可以扩展读取和写入功能以支持自定义类型：

func Read(r io.Reader, order binary.ByteOrder, data interface{}) error {
    switch data := data.(type) {
    case *foo:
        return readFoo(r, order, data)
    // (...)
    default:
        return binary.Read(r, order, data)
    }
}

func Write(w io.Writer, order binary.ByteOrder, data interface{}) error {
    switch data := data.(type) {
    case foo:
        return writeFoo(r, order, data)
    // (...)
    default:
        return binary.Write(r, order, data)
    }
}

使用包含所有联合字段的结构，并使用应用程序上下文来决定将哪个值编码到 C 联合中。

type foo struct {
    is_i bool
    i    int32
    f    float32
}

// Read a foo from r into data
func readFoo(r io.Reader, order binary.ByteOrder, data *foo) error {
    b := make([]byte, 4)
    if _, err := io.ReadFull(r, b); err != nil {
        return err
    }

    *data = foo{
        i: int32(order.PutUint32(b)),
        f: float32(order.PutUint32(b)),
    }

    return nil
}

// Write a foo from data into w
func writeFoo(w io.Writer, order binary.ByteOrder, data foo) error {
    b := make([]byte, 4)

    if data.is_i {
        order.PutUint32(b, uint32(data.i))
    } else {
        order.PutUint32(b, uint32(data.f))
    }

    _, err := w.Write(b)
    return err
}

（或者，使用 getter 和 setter：http://pastebin.com/H1QW5AFb http://pastebin.com/H1QW5AFb)

使用按位运算来封送位域

type bar struct {
    x bool
    y uint
    z uint
}

// Read a bar from r into data
func readBar(r io.Reader, order binary.ByteOrder, data *foo) error {
    b := make([]byte, 1)
    if _, err := io.ReadFull(r, b); err != nil {
        return err
    }

    // Read from bitfield
    *data = bar{
        x: bool(b[0] >> 7),          // bool x:1;
        y: uint((b[0] & 0x70) >> 3), // unsigned int y:3;
        z: uint(b[0] & 0x0f),        // unsigned int z:4;
    }

    return nil
}

// Write a bar from data into w
func writeBar(w io.Writer, order binary.ByteOrder, data bar) error {
b := make([]byte, 1)

    var x uint8
    if data.x {
        x = 1
    }
    // Create bitfield
    b[0] = (x & 0x01 << 7) & // bool x:1;
        (uint8(data.y) & 0x03 << 4) & // unsigned int y:3;
        (uint8(data.z) & 0x04) // unsigned int z:4;
    _, err := w.Write(b)
    return err
}

baz 的序列化形式取决于编译器对complex 的内部定义。 使用时encoding.binary，字段具有 1 字节对齐方式，因此 quux 可以直接封送。