从 C 访问 Go 的数组数组

Question

澄清： 似乎没有将 GO 映射作为多维数组发送到 C 函数的文档示例。这个问题旨在为任何将数据集合从 GO 发送到 C 的人找到一个通用的解决方案。

问题： 我在 Go 中有一个 map[string]string，我希望在 C++ 中迭代这个 key/value 对。

在 GO 中，我有以下创建多维数组的方法

    var argv = make([][]*C.char, len(keypairs))
    count := 0
    for key, val := range keypairs {
        var argv2 = make([]*C.char, 2)
        csKey := C.CString(key)
        csVal := C.CString(val)

        argv2[0] = csKey
        argv2[1] = csVal
        argv[count] = argv2
        count++

        C.free(unsafe.Pointer(csKey))
        C.free(unsafe.Pointer(csVal))
    }
    C.writeKeyValuePairs(&argv[0])

然后在 C++ 中我有：

bool writeKeyValuePairs(char * pairs[][2]) {
     ...
}

结果是： cannot use _cgo1 (type *[]*_Ctype_char) as type *[2]*_Ctype_char in argument

更新@kostix： 这是现在的位置：

    var argv = make([][2]*C.char, len(tags))
    i := 0
    for key, val := range tags {
        var argv2 = new([2]*C.char)
        argv2[0], argv2[1] = C.CString(key), C.CString(val)
        argv[i] = argv2
        i++
    }
    C.writeKeyValuePairs(&argv[0])

错误是： Cannot use 'argv2' (type *[2]*C.char) as type [2]*C.char

Answer 1

在 Go 中，[]T 不是你想的那样：它不是数组而是切片。

切片是 struct 三个字段：length int、capacity int 和指向底层（后备）数组第一个元素的指针。

相反，在 C 和 C++ 中，T[] 是直接指向内存块的指针（迭代恰好在 sizeof(T) 字节中完成大块）。

因此你的char *pairs[][2]是

指向两个char*[]、
其中每个元素都是指向另一个未知数量元素数组的指针，类型为 char*。

…而你的 Go 的 [][]*C.char 是切片的切片（即 struct 类型的切片 headers，而不是指针）。

您可能需要这样的东西：

    var argv = make([][2]*C.char, len(keypairs))
    i := 0
    for key, val := range keypairs {
        var argv2 = new([2]*C.char)
        argv2[0], argv2[1] := C.CString(key), C.CString(val)
        argv[i] = argv2
        i++
    }
    C.writeKeyValuePairs(&argv[0])

这里我们分配了一个数组片段（长度为2）。调用C端时正确获取了封闭数组的第一个元素的地址，所以在顶层有一个切片就好了。

这段代码的问题是你没有传达 argv 到 writeKeyValuePairs 中的数据长度，你也不在该数组的末尾使用标记值，但我希望你刚刚从你的示例中删除了那一点。

我也不明白你为什么马上释放C.CString分配的内存。 manual 表示：

// Go string to C string
// The C string is allocated in the C heap using malloc.
// It is the caller's responsibility to arrange for it to be
// freed, such as by calling C.free (be sure to include stdlib.h
// if C.free is needed).
func C.CString(string) *C.char

所以你似乎在将指向它们的指针分配给相应的数组条目对之后立即释放 key/value 对的内存块。我怀疑这是一个错误：释放必须在 C 函数完成执行后进行。

更新截至 2019 年 7 月 26 日：

这是工作代码：

package main

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

    void writeKeyValuePairs(char *v[][2], size_t len) {
        int i;
        for (i = 0; i < len; i++) {
            printf("i=%i, k=%s, v=%s\n", i, v[i][0], v[i][1]);
        }
        return;
    }
*/
import "C"

import "unsafe"

func main() {
    tags := map[string]string{
        "foo": "42",
        "bar": "12",
    }

    var argv = make([][2]*C.char, len(tags))
    i := 0
    for key, val := range tags {
        var kv [2]*C.char
        kv[0], kv[1] = C.CString(key), C.CString(val)
        argv[i] = kv
        i++
    }

    defer func(items [][2]*C.char) {
        for i := range items {
            k, v := items[i][0], items[i][1]
            C.free(unsafe.Pointer(k))
            C.free(unsafe.Pointer(v))
        }
    }(argv)

    C.writeKeyValuePairs(&argv[0], C.size_t(len(tags)))
}

结果：

$ go build c.go
$ ./c
i=0, k=foo, v=42
i=1, k=bar, v=12

Answer 2

I have a map[string]string in Go, I'm looking to iterate over this key/value pair in C++.

使用你的例子，

package main

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

bool writeKeyValuePairs(char *pairs[][2], size_t size) {
    for (size_t i = 0; i < size; i++ ) {
        if (fprintf(stdout, "%s: %s\n", pairs[i][0], pairs[i][1]) < 0) {
            return false;
        }
    }
    return true;
}
*/
import "C"

import (
    "fmt"
    "os"
    "unsafe"
)

func allocCPairs(m map[string]string) (*[2]*C.char, C.size_t) {
    kv := make([][2]*C.char, 0, len(m)+1)
    for k, v := range m {
        kv = append(kv, [2]*C.char{0: C.CString(k), 1: C.CString(v)})
    }
    return &kv[:cap(kv)][0], C.size_t(len(kv))
}

func freeCPairs(cPairs *[2]*C.char, size C.size_t) {
    gPairs := (*[1 << 30][2]*C.char)(unsafe.Pointer(cPairs))[:size]
    for _, pair := range gPairs {
        for _, p := range pair {
            C.free(unsafe.Pointer(p))
        }
    }
}

func writeKeyValuePairs(m map[string]string) error {
    cPairs, size := allocCPairs(m)
    defer freeCPairs(cPairs, size)

    rv := C.writeKeyValuePairs(cPairs, size)
    if !rv {
        return fmt.Errorf("writeKeyValuePairs: write error")
    }
    return nil
}

func main() {
    m := map[string]string{
        "K1": "V1",
        "K2": "V2",
        // ...
        "Kn": "Vn",
    }
    fmt.Println(m)

    err := writeKeyValuePairs(m)
    if err != nil {
        fmt.Fprintln(os.Stderr, err)
        return
    }
}

输出：

map[K1:V1 K2:V2 Kn:Vn]
K1: V1
K2: V2
Kn: Vn

从 C 访问 Go 的数组数组

Access Go's array of arrays from C

arrays

go

multidimensional-array

cgo