C構造体を翻訳するための良いまたは推奨される方法

Question

GOからライブラリバインディングを開発するためのCGOを使用しています。 C構造体と下記のような構造体を検討しましょう。

struct cons_t {
  size_t type;
  cons_t *car;
  cons_t *cdr;
};

cons_t* parse(const char *str);

.

そしてこれはGoの構造

です

type Cons struct {
  type int;
  car *Cons;
  cdr *Cons;
}

.

GO機能を以下のように実装するために、TranslateCcons2Goconsを実装するための優れた方法は何ですか？

func Parse (str string) *Cons {
  str_ptr := C.CString(string);
  cons_ptr := C.parse(str_ptr);
  retCons := TranslateCCons2GoCons(cons_ptr);
  return retCons;
}

.

私の最初の答えは以下の通りです。

/*#cgo
int getType(cons_t *cons) {
    return cons->type;
}
cons_t *getCar(cons_t *cons) {
  return cons->car;
}
cons_t *getCdr(cons_t *cons) {
  return cons->cdr;
}
*/

func TranslateCCons2GoCons (c *C.cons_t) Cons {
  type := C.getType(c);
  car := C.getCar(c);
  cdr := C.getCdr(c);
  // drop null termination for simplicity
  return Cons{type, TranslateCCons2GoCons(car), TranslateCCons2GoCons(cdr)};
}

.

はどんな良くやり方ですか？

Answer 1

アクセサ関数に対してお勧めします。C構造体のフィールドに直接アクセスできるはずです。これは、Go - > C関数呼び出しオーバーヘッド（非些細なものです）を回避します。だからあなたは何かを使うかもしれません：

func TranslateCCons2GoCons (c *C.cons_t) *Cons {
    if c == nil {
        return nil
    }
    return &Cons{
        type: int(c.type),
        car: TranslateCCons2GoCons(c.car),
        cdr: TranslateCCons2GoCons(c.cdr),
    }
}

.

また、C.CStringを使用してC文字列を割り当てる場合は、それを解放する必要があります。そのため、Parse関数は次のようになります。

func Parse (str string) *Cons {
    str_ptr := C.CString(str)
    defer C.free(unsafe.Pointer(str_ptr)
    cons_ptr := C.parse(str_ptr)
    retCons := TranslateCCons2GoCons(cons_ptr)
    // FIXME: Do something to free cons_ptr here.  The Go runtime won't do it for you
    return retCons
}

.

Answer 2

GOの構造体を使用できます（ただし、structがunionを保持している場合は、もう少し複雑になります）。最も簡単な方法はただ

type Cons struct {
    c C.cons_t
}

.

Cの任意の機能は現在、Go

のほんのパススルーです。

func Parse(s string) Cons {
    str := C.CString(s)
    // Warning: don't free this if this is stored in the C code
    defer C.free(unsafe.Pointer(str))
    return Cons{c: C.parse(str)}
}

.

要素アクセスでタイプの変換をしなければならないので、これはそれ自身のオーバーヘッドを持っています。だからvar c Cons{}; c.Typeの前に何が今

func (c Cons) Type() int {
    return int(c.c.type)
}

.

簡単にアクセスできるようにするために、Cタイプと並んでフィールドを保存する中間妥協点を使用できます。

type Cons struct {
    type int
    c C.cons_t
}

func (c *Cons) SetType(t int) {
    c.type = t
    c.c.type = C.size_t(t)
}

func (c Cons) Type() int {
    return c.type
}

.

これが本当の問題点は、C関数をたくさん呼び出すと、Go側フィールドの設定にメンテナンスのオーバーヘッドを導入することができます。

func (c *Cons) SomeFuncThatAltersType() {
    C.someFuncThatAltersType(&c.c)
    c.Type = int(c.c.type) // now we have to remember to do this
}

.