使用cgo时构造非基础字符串切片触发运行时错误求助

我来帮你拆解这个问题：你遇到的panic是cgo安全规则触发的，核心原因是拼接后的字符串底层内存依赖于其他Go字符串，导致你的[]string切片里的字符串结构体包含了指向Go内存的指针，而你又把整个切片的指针传递给了C，形成了"Go指针指向Go指针"的嵌套结构，这直接违反了cgo的安全约束。

为什么基础字符串切片没问题？ #

像"blah"这种字面量字符串，它们的底层内存存储在程序的只读数据段（不属于Go堆管理的内存），所以当你把这些字符串的指针传递给C时，cgo不会判定为违规情况。

而拼接出来的字符串（比如"ns: "+s[0]），Go会在堆上分配新的内存（或栈上，仍属于Go管理的内存），这个字符串的底层指针指向的是Go自己管控的内存块。当你把包含这类字符串的[]string转换成_goslice_传递给C时，_goslice_.array是一个Go指针（指向切片的底层数组），而数组里每个_gostring_.p又是另一个Go指针（指向拼接字符串的底层内存）——这就触发了cgo的安全检查，因为cgo明确禁止传递包含Go指针的Go指针到C端。

解决方案：把字符串内容复制到C管理的内存 #

正确的做法是，在Go端先把每个字符串的内容复制到C堆内存（用C.CString），然后构造一个C端的字符串数组，再传递给C函数，最后记得释放这些内存避免泄漏。

修改后的代码如下：

package main
import (
 "fmt"
 "reflect"
 "unsafe"
)
/*
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

void prtText(char * const *txt, int len) {
 int i = 0;
 for ( i=0; i<len; i++ ) {
 printf("Text %d is: %s\n", i, txt[i]);
 }
}
*/
import "C"

func PrintText(arg1 []string) {
 // 分配C端的字符串指针数组
 cStrs := (*[1 << 30]*C.char)(C.calloc(C.int(len(arg1)), C.sizeof_charPtr))
 if cStrs == nil {
 panic("failed to allocate c string array")
 }
 defer C.free(unsafe.Pointer(cStrs))

 // 把每个Go字符串复制到C内存，并赋值给数组
 for i, s := range arg1 {
 cStr := C.CString(s)
 if cStr == nil {
 // 如果分配失败，先释放已分配的内存
 for j := 0; j < i; j++ {
 C.free(unsafe.Pointer(cStrs[j]))
 }
 panic("failed to allocate c string")
 }
 cStrs[i] = cStr
 defer C.free(unsafe.Pointer(cStrs[i]))
 }

 // 调用C函数
 C.prtText((**C.char)(unsafe.Pointer(cStrs)), C.int(len(arg1)))
}

func main() {
 s := []string{}
 s = append(s, "blah")
 s = append(s, "hello")
 s = append(s, "again")
 ns := []string{}
 ns = append(ns, "ns: "+s[0])
 ns = append(ns, "ns: "+s[1])
 ns = append(ns, "ns: "+s[2])
 fmt.Println("type s:", reflect.TypeOf(s))
 fmt.Println("type ns:", reflect.TypeOf(ns))
 fmt.Println("s:", s)
 fmt.Println("ns:", ns)
 PrintText(s)
 PrintText(ns)
}

代码说明： #

1. 用C.calloc分配一个C端的字符串指针数组，长度和Go切片一致。
2. 遍历Go切片，用C.CString把每个Go字符串复制到C堆内存，返回的指针由C管理，不会触发cgo的指针检查。
3. 用defer确保所有分配的C内存都会被释放，避免内存泄漏。
4. 直接调用prtText，传递C端的数组指针和长度，不再需要自定义的_wrap_printText函数。

运行验证： #

编译运行后，输出会是：

type s: []string
type ns: []string
s: [blah hello again]
ns: [ns: blah ns: hello ns: again]
Text 0 is: blah
Text 1 is: hello
Text 2 is: again
Text 0 is: ns: blah
Text 1 is: ns: hello
Text 2 is: ns: again

不会再触发panic。

内容的提问来源于stack exchange，提问作者Jon Scobie