Go语言通过CGO传递结构体与结构体数组：类型对齐与实践

package main

/*
#include <stdio.h>

typedef struct {
    int a;
    int b;
} Foo;

void pass_array(Foo **in) { // C函数期望一个Foo指针数组
    int i;
    for(i = 0; i < 2; i++) {
        fprintf(stderr, "C (array of pointers): [%d, %d]\n", in[i]->a, in[i]->b);
    }
    fprintf(stderr, "\n");
}

void pass_struct(Foo *in) {
    fprintf(stderr, "C (single struct): [%d, %d]\n", in->a, in->b);
}

*/
import "C"

import (
    "unsafe"
)

// 原始Go结构体定义
type Foo struct {
    A int
    B int
}

func main() {
    foo := Foo{25, 26}
    // 错误示例1: 单个结构体，可能因int大小不匹配导致错误
    // C.pass_struct((*_Ctype_Foo)(unsafe.Pointer(&foo))) // 结果可能为 [25, 0]

    // 错误示例2: 直接传递Go切片首地址给C的**Foo，导致SIGSEGV
    // foos := []Foo{{25, 26}, {50, 51}}
    // C.pass_array((**_Ctype_Foo)(unsafe.Pointer(&foos[0])))

    // 错误示例3: 创建Go的*_Ctype_Foo指针切片，但仍可能因类型不匹配导致错误
    // out := make([]*_Ctype_Foo, len(foos))
    // out[0] = (*_Ctype_Foo)(unsafe.Pointer(&foos[0]))
    // out[1] = (*_Ctype_Foo)(unsafe.Pointer(&foos[1]))
    // C.pass_array((**_Ctype_Foo)(unsafe.Pointer(&out[0]))) // 结果可能为 [25, 0], [50, 0]
}

// Go结构体定义，显式匹配C的int32
type Foo struct {
    A int32
    B int32
}

// Go结构体定义，直接映射C的Foo类型
type Foo C.Foo

package main

/*
#include <stdio.h>
#include <stdlib.h> // For malloc, free, if needed

typedef struct {
    int a;
    int b;
} Foo;

// C函数：接收单个Foo结构体指针
void pass_struct(Foo *in) {
    fprintf(stderr, "C (single struct): [%d, %d]\n", in->a, in->b);
}

// C函数：接收Foo结构体指针数组（即 **Foo）
// 注意：C函数假设该数组至少包含2个元素
void pass_array(Foo **in) {
    int i;
    for(i = 0; i < 2; i++) { // C代码假设固定大小为2
        fprintf(stderr, "C (array of pointers): [%d, %d]\n", in[i]->a, in[i]->b);
    }
    fprintf(stderr, "\n");
}

*/
import "C" // 导入C包，以便使用C类型和函数

import (
    "unsafe" // 导入unsafe包，用于指针操作
)

// Go结构体定义：直接映射C的Foo类型，确保内存布局一致
type Foo C.Foo

func main() {
    // --- 1. 传递单个结构体 ---
    // 创建一个Go的Foo结构体实例
    goFoo := Foo{A: 25, B: 26}
    // 将Go结构体的地址转换为C.Foo指针，然后传递给C函数
    C.pass_struct((*C.Foo)(unsafe.Pointer(&goFoo)))
    // 预期输出: C (single struct): [25, 26]

    // --- 2. 传递结构体指针数组 ---
    // 2.1 创建一个Go的Foo结构体切片
    goFoos := []Foo{{A: 100, B: 101}, {A: 200, B: 201}}

    // 2.2 创建一个Go切片，其元素是指向C.Foo类型的指针。
    // 这个切片将存储goFoos中每个元素的地址，并以C.Foo*类型表示。
    // C函数期望的是Foo**，即一个指向Foo*的指针，所以我们需要一个Foo*的连续数组。
    cFooPointers := make([]*C.Foo, len(goFoos))
    for i := range goFoos {
        // 将Go结构体元素的地址转换为C.Foo指针
        cFooPointers[i] = (*C.Foo)(unsafe.Pointer(&goFoos[i]))
    }

    // 2.3 将cFooPointers切片的第一个元素的地址传递给C函数。
    // &cFooPointers[0]的类型是**C.Foo，这正是C函数pass_array所期望的Foo**。
    C.pass_array((**C.Foo)(unsafe.Pointer(&cFooPointers[0])))
    // 预期输出:
    // C (array of pointers): [100, 101]
    // C (array of pointers): [200, 201]
}