Go与CGO：将C语言的unsigned char*转换为Go的[]byte

// C代码部分，通常放在Go文件的注释块中
#include <stdlib.h> // For malloc, free
#include <string.h> // For memset, strdup

typedef struct {
    unsigned char *data;
    unsigned int data_len;
} Result;

Result *foo() {
    Result *r = (Result *)malloc(sizeof(Result));
    if (r == NULL) {
        // Handle allocation error
        return NULL;
    }

    // 初始分配并清零，虽然在strdup后会被覆盖，但展示了内存分配
    r->data = (unsigned char *)malloc(10);
    if (r->data == NULL) {
        free(r);
        return NULL;
    }
    memset(r->data, 0, 10);

    // strdup会分配新的内存并复制字符串，注意这里可能导致r->data原先分配的内存泄漏
    // 在实际生产代码中，应避免此类内存泄漏，例如先free(r->data)
    // 为了示例的简洁性，此处保留原样
    unsigned char *temp_data = (unsigned char *)strdup("xxx123");
    if (temp_data == NULL) {
        free(r->data);
        free(r);
        return NULL;
    }
    free(r->data); // 释放之前malloc的内存，避免泄漏
    r->data = temp_data;
    r->data_len = strlen((char *)r->data); // 获取实际字符串长度

    return r;
}

// 示例中未包含释放Result的函数，但在实际应用中应提供
void freeResult(Result *r) {
    if (r != NULL) {
        if (r->data != NULL) {
            free(r->data);
        }
        free(r);
    }
}

package main

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

typedef struct {
    unsigned char *data;
    unsigned int data_len;
} Result;

Result *foo() {
    Result *r = (Result *)malloc(sizeof(Result));
    if (r == NULL) { return NULL; }

    unsigned char *temp_data = (unsigned char *)strdup("xxx123");
    if (temp_data == NULL) { free(r); return NULL; }

    r->data = temp_data;
    r->data_len = strlen((char *)r->data);

    return r;
}

void freeResult(Result *r) {
    if (r != NULL) {
        if (r->data != NULL) {
            free(r->data);
        }
        free(r);
    }
}
*/
import "C" // 导入C语言代码

import (
    "fmt"
    "unsafe" // 导入unsafe包用于指针转换
)

func main() {
    result := C.foo()
    if result == nil {
        fmt.Println("Error: C.foo() returned nil")
        return
    }
    defer C.freeResult(result) // 确保C语言分配的内存被释放

    // 尝试直接打印，只能获取指针地址和第一个字符
    fmt.Printf("C指针地址: %v, 第一个字符: %v, 长度: %v\n", result.data, string(*(result.data)), result.data_len)
    // 输出可能为: C指针地址: 0x... , 第一个字符: x, 长度: 6

    // 目标：将 result.data (unsigned char *) 转换为 Go 的 []byte
    // 或先转换为 Go 的 string，再转换为 []byte
}

// ... (接上面的main函数代码)

    // 1. 将 *C.uchar 转换为 *C.char
    cDataPtr := (*C.char)(unsafe.Pointer(result.data))
    // 2. 将 C.uint 转换为 C.int
    cDataLen := C.int(result.data_len)

    // 3. 使用 C.GoStringN 将 C 字符串转换为 Go 字符串
    goString := C.GoStringN(cDataPtr, cDataLen)
    fmt.Printf("转换为Go字符串 (C.GoStringN): %s\n", goString) // 输出: 转换为Go字符串 (C.GoStringN): xxx123

    // 4. 将 Go 字符串转换为 []byte
    goBytes := []byte(goString)
    fmt.Printf("转换为Go字节切片 (C.GoStringN): %v\n", goBytes) // 输出: 转换为Go字节切片 (C.GoStringN): [120 120 120 49 50 51]
}

// ... (接上面的main函数代码)

    // 简化方案：针对空终止字符串使用 C.GoString
    // 同样需要将 *C.uchar 转换为 *C.char
    cDataPtrForString := (*C.char)(unsafe.Pointer(result.data))
    goStringSimple := C.GoString(cDataPtrForString)
    fmt.Printf("转换为Go字符串 (C.GoString): %s\n", goStringSimple) // 输出: 转换为Go字符串 (C.GoString): xxx123

    goBytesSimple := []byte(goStringSimple)
    fmt.Printf("转换为Go字节切片 (C.GoString): %v\n", goBytesSimple) // 输出: 转换为Go字节切片 (C.GoString): [120 120 120 49 50 51]
}