Go与C结构体交互：解决cgo中结构体和结构体数组传递的内存对齐问题

// C语言定义
typedef struct {
    int a; // 假设为32位（4字节）
    int b; // 假设为32位（4字节）
} Foo;
// 整体大小：4 + 4 = 8字节

// Go语言定义
type Foo struct {
    A int // 在64位系统上为64位（8字节）
    B int // 在64位系统上为64位（8字节）
}
// 在64位系统上，整体大小：8 + 8 = 16字节

package main

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

typedef struct {
    int a; // C int typically 32-bit
    int b; // C int typically 32-bit
} Foo;

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

// C function to receive an array of pointers to Foo structs
// Added 'count' for robustness, as C doesn't know array size
void pass_array(Foo **in, int count) {
    int i;
    fprintf(stderr, "C: Received array of %d Foo pointers:\n", count);
    for(i = 0; i < count; i++) {
        fprintf(stderr, "C:   [%d, %d]\n", in[i]->a, in[i]->b);
    }
}
*/
import "C"

import (
    "fmt"
    "unsafe"
)

// Go struct with explicit 32-bit integers to match C's int
type Foo struct {
    A int32
    B int32
}

func main() {
    fmt.Println("--- Solution 1: Explicit Type Alignment ---")

    // 1. 传递单个结构体
    foo := Foo{A: 25, B: 26}
    fmt.Println("Go: Passing single struct:", foo)
    // 将Go struct的地址转换为C struct的指针类型
    C.pass_struct((*_Ctype_Foo)(unsafe.Pointer(&foo)))

    // 2. 传递结构体数组 (C函数期望 Foo**)
    goFoos := []Foo{
        {A: 25, B: 26},
        {A: 50, B: 51},
    }
    fmt.Println("Go: Original Go slice of structs:", goFoos)

    // 创建一个Go切片，其中包含指向C类型Foo的指针
    // 这是因为C函数 `pass_array` 期望 `Foo **in`，即一个指向指针数组的指针
    cFooPtrs := make([]*_Ctype_Foo, len(goFoos))
    for i := range goFoos {
        cFooPtrs[i] = (*_Ctype_Foo)(unsafe.Pointer(&goFoos[i]))
    }

    fmt.Println("Go: Passing array of structs (as array of pointers) to C:")
    // 将指向 cFooPtrs 切片第一个元素的指针（它本身是一个指针）转换为 `**_Ctype_Foo`
    C.pass_array((**_Ctype_Foo)(unsafe.Pointer(&cFooPtrs[0])), C.int(len(cFooPtrs)))
}

package main

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

typedef struct {
    int a; // C int typically 32-bit
    int b; // C int typically 32-bit
} Foo;

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

// C function to receive an array of pointers to Foo structs
// Added 'count' for robustness, as C doesn't know array size
void pass_array(Foo **in, int count) {
    int i;
    fprintf(stderr, "C: Received array of %d Foo pointers:\n", count);
    for(i = 0; i < count; i++) {
        fprintf(stderr, "C:   [%d, %d]\n", in[i]->a, in[i]->b);
    }
}
*/
import "C"

import (
    "fmt"
    "unsafe"
)

// 将Go的Foo结构体直接别名为C的_Ctype_Foo
// 这确保了Go和C结构体具有完全相同的内存布局和字段类型
type Foo _Ctype_Foo

func main() {
    fmt.Println("\n--- Solution 2: Direct C Type Aliasing (Recommended) ---")

    // 1. 传递单个结构体
    foo := Foo{A: 25, B: 26} // 使用别名类型Foo
    fmt.Println("Go: Passing single struct:", foo)
    // 直接将Go struct的地址转换为C struct的指针类型
    C.pass_struct((*_Ctype_Foo)(unsafe.Pointer(&foo)))

    // 2. 传递结构体数组 (C函数期望 Foo**)
    goFoos := []Foo{
        {A: 25, B: 26},
        {A: 50, B: 51},
    }
    fmt.Println("Go: Original Go slice of structs:", goFoos)

    // 创建一个Go切片，其中包含指向C类型Foo的指针
    cFooPtrs := make([]*_Ctype_Foo, len(goFoos))
    for i := range goFoos {
        cFooPtrs[i] = (*_Ctype_Foo)(unsafe.Pointer(&goFoos[i]))
    }

    fmt.Println("Go: Passing array of structs (as array of pointers) to C:")
    // 将指向 cFooPtrs 切片第一个元素的指针转换为 `**_Ctype_Foo`
    C.pass_array((**_Ctype_Foo)(unsafe.Pointer(&cFooPtrs[0])), C.int(len(cFooPtrs)))
}