Go cgo 怎样把 C 字符串转换为 Go 字符串

把以 NUL（零字节）结尾的 *C.char 转成 Go 字符串，使用 C.GoString(p)；如果 C 接口提供的是“指针加字节长度”，则使用 C.GoStringN(p, n)。两者会复制数据，得到的 Go 字符串不依赖原 C 缓冲区继续存在，但转换不会自动释放原内存，也不会替你转换字符编码。

我更倾向于把这次改动理解为接口收口：在 cgo 包内部处理长度、所有权和错误，对外只返回普通 Go 值。这里讨论的是已有能力的使用与旧代码改造，不是一项新版本发布；示例为原创教学片段，未声称本机运行结果。

cgo 官方文档：https://pkg.go.dev/cmd/cgo

改动一句话：把字符指针复制为 Go 值

C 的字符指针只提供地址，不直接携带 Go 字符串所需的长度。转换时必须从协议中知道“在哪里结束”：可能是第一个 NUL，也可能是独立长度字段。仅仅知道类型为 *C.char，还不足以决定该读多少字节。

C.GoString 与 C.GoStringN 都是 cgo 提供的特殊转换函数，不需要在 C 头文件里声明它们。Go 文件通过 import "C" 使用这些入口；它们不等同于普通标准库包中的导出函数。

完成复制后，原 C 内存可以按其拥有者约定释放或复用，Go 字符串仍然保存复制得到的内容。前提是复制发生时源地址有效、读取范围合法，而且没有其他线程同时修改这段数据。复制不能修复悬空指针或并发读写。

为什么分两种接口：终止符和长度是不同契约

例如 C 缓冲区含五个字节 A、B、NUL、C、D。按 C 字符串读取只能得到 AB；按长度五复制，则得到包含中间零字节的 Go 字符串。Go 的 string 是不可变字节序列，允许内部含零，长度按字节计算。

不要为了避免截断就给 GoStringN 随意填一个大数。它不负责探测地址后面还有多少可读空间，也不负责识别字符串结束。反过来，对没有终止符的缓冲区调用 GoString，可能读出分配范围之外。

旧代码的影响：复制数据不转移释放责任

最容易遗漏的部分是所有权。C 库返回的字符串可能属于静态区、库内部缓冲区，也可能需要调用方释放。应先看该库的接口说明，再选择释放方式。静态字符串不能 free；库要求调用专用析构函数时，也不能用一个通用 free 代替。

下面的完整程序把两种来源放在一起：borrowed_label 返回静态字符数组，调用者只借用；C.CString 在 C 堆上分配数据，由当前函数负责 C.free。使用 CString 只是为了给示例提供一个明确拥有者的 C 缓冲区，实际工程可换成自己的 C 库返回值。

package main

/*
#include 

// 静态缓冲区属于本函数内部存储，调用方不得释放。
static const char *borrowed_label(void) {
    static const char text[] = "device-ready";
    return text;
}
*/
import "C"

import (
    "fmt"
    "unsafe"
)

func readBorrowed() string {
    p := C.borrowed_label()
    // 在静态源仍有效时复制；这里不调用 free。
    return C.GoString(p)
}

func copyOwned() string {
    p := C.CString("sensor-online")
    // 当前函数拥有这块 C 堆内存，复制完成后释放。
    defer C.free(unsafe.Pointer(p))
    return C.GoString(p)
}

func main() {
    fmt.Println(readBorrowed())
    fmt.Println(copyOwned())
}

返回表达式先完成 GoString，函数退出时 defer 再释放 owned 缓冲区，因此返回值不悬挂在已释放的 C 地址上。把 free 提到复制之前就会破坏这个条件。不要为了“留住字符串”而省略应有的释放；复制出来的 Go 字符串和源 C 分配是两个对象。

这里在 C 前导注释中包含 stdlib.h，提供 free 的声明；前导注释与 import "C" 紧邻。C 代码中用有效的 C 注释说明责任，Go 部分的注释则说明复制与资源清理。

迁移建议：把长度和编码留在接口边界

当旧接口从 NUL 文本升级为“指针加长度”，应同步换成 GoStringN。下面是独立的小程序，C 函数返回五字节静态数据和精确长度，缓冲区没有额外末尾终止符。

package main

/*
// 该缓冲区不提供字符串终止符，必须通过返回长度读取。
static const char *packet_text(int *length) {
    static const char data[] = {'A', 'B', 0, 'C', 'D'};
    *length = (int)sizeof(data);
    return data;
}
*/
import "C"

import "fmt"

func readPacket() (string, error) {
    var n C.int
    p := C.packet_text(&n)
    // 示例协议限定最大长度；真实上限由业务协议确定。
    if n  4096 {
        return "", fmt.Errorf("长度不符合协议: %d", int(n))
    }
    if n == 0 {
        return "", nil
    }
    if p == nil {
        return "", fmt.Errorf("非零长度缺少数据地址")
    }
    return C.GoStringN(p, n), nil
}

func main() {
    s, err := readPacket()
    if err != nil {
        fmt.Println(err)
        return
    }
    // %q 显示中间的零字节，len 统计字节而不是字符。
    fmt.Printf("%q len=%d\n", s, len(s))
}

按示例字节定义，结果应保留 AB 与 CD 之间的零，长度应为五；这是一种预期结果说明。非负和业务上限判断能拦住部分错误元数据，不能证明地址实际指向足够长的缓冲区，后者仍是 C 接口必须履行的约定。

GoStringN 的长度参数为 C.int。如果真实库返回 size_t 或其他更宽类型，先确认非负、业务上限、目标 C.int 的可表示范围，再进行窄化；不能先强转再判断溢出后的值。本例直接让 C 返回受控的 int，避免把这个额外问题隐藏进演示。

编码也要单独约定。若 C 返回的是 UTF-8，复制后可以按 UTF-8 处理；若是其他编码，复制只保留原字节，不能自动变成正确中文。二进制数据不应为了显示方便就按文本解码。返回 Go string 也不意味着其中内容一定是合法 UTF-8。

我建议将 C 类型限制在绑定包内部，对外返回 (string, error) 或字节数据。这样调用者不必了解哪个指针能释放，包内部也能统一处理 NULL、长度和库专用释放函数。

最小使用示例与常见问题

将两个完整示例分别保存、分别运行，不要把两段 main 函数直接放在同一个程序里。构建需要启用 cgo，并且有适合目标平台的 C 编译器；仅设置开关不会自动安装编译器。

# 在配置好本机 C 编译器的环境中运行一个完整示例。
CGO_ENABLED=1 go run main.go

关闭 cgo 时，导入 C 的 Go 文件不会参与构建；交叉编译还需要匹配目标的 C 工具链。代码里的 GoString 和 GoStringN 选择规则不因这些构建条件而改变。

NULL 能不能直接当空字符串？先依据 C 库契约区分“空值”和“失败”。包装层可以在允许空数据时明确返回空字符串，在非零长度却没有地址时返回错误，避免丢掉错误语义。

GoString 转完为什么 C 堆仍增长？转换不会释放源内存。核对每个需要调用方清理的 C 返回值是否有匹配释放；不要对静态区或借用内存套用同一释放规则。

能否直接用 unsafe 把 C 地址变成零拷贝字符串？这会让 Go 值继续依赖外部内存的寿命与不可修改约定，不再具有本文复制方案的所有权优势。普通文本接口优先复制，除非已经完整设计外部内存管理。

字符串为什么在中间少了一截？先看源数据是否包含零字节、接口是否有有效长度。NUL 文本和带长度数据应使用不同复制入口，不能只按指针类型决定。

Go 字符串规范：https://go.dev/ref/spec#String_types