在 C 中访问 Go 数组

在 C 和 Go 语言之间传递数据时，有时需要将 Go 中的多维数组发送到 C 函数。然而，直接将 Go 映射作为多维数组发送到 C 函数的记录示例并不多见。本文旨在为需要将数据集合从 Go 发送到 C 的开发人员提供一个通用的解决方案。通过使用 C 语言的数组和 Go 语言的切片，我们可以创建一个高效且通用的方法，在不同语言之间交换数据。

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

问题： 我在 go 中有一个 map[string]string，我希望在 c++ 中迭代这个键/值对。

在 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]) {
     ...
}

结果是： 不能在参数中使用_cgo1（类型*[]*_ctype_char）作为类型*[2]*_ctype_char

更新@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])

错误是： 不能使用“argv2”（类型*[2]*c.char）作为类型[2]*c.char

解决方案

在 go 中，[]t 并不是你想象的那样： 它不是一个数组，而是一个切片。

切片是一个包含三个字段的 struct：length int、capacity int 和指向基础（支持）数组的第一个元素的指针。

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

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

• 指向 char*[] 类型的两个元素的内存块的指针，
• 其中每个元素都是指向另一个 char* 类型元素的数组的指针。

…你的 go 的 [][]*c.char 是一个切片的切片（即 struct 类型的切片头，而不是指针）。

你可能需要这样的东西：

    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

因此，在指向键/值对的指针被分配给相应的数组条目对之后，您似乎立即释放了键/值对的内存块。 我怀疑这是一个错误：释放必须在 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

使用您的示例，

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 数组》的介绍应该让你收获多多了吧！欢迎大家收藏或分享给更多需要学习的朋友吧~golang学习网公众号也会发布Golang相关知识，快来关注吧！