Go Cgo 结构体数组与指针传递：避免类型不匹配的陷阱

#ifndef __T32_H__
#define __T32_H__

typedef unsigned char byte;
typedef unsigned short word;
typedef unsigned int dword;

typedef struct t32_breakpoint {
    dword address;
    byte  enabled;
    dword type;
    dword auxtype;
} T32_Breakpoint; // 注意这里typedef了一个新名字 T32_Breakpoint


int T32_GetBreakpointList( int *, T32_Breakpoint*, int );

#endif /* __T32_H__ */

#include "t32.h"

int T32_GetBreakpointList (int* numbps, T32_Breakpoint* bps, int max)
{ 
    // 实际的C逻辑，这里简化为返回0
    return 0;
}

package t32

// #cgo ...
// #include "t32.h"
import "C"
import (
    "errors"
    "unsafe"
)

// Go侧对应的结构体，用于数据转换
type BreakPoint struct {
    Address uint32
    Enabled int8
    Type    uint32
    Auxtype uint32
}

func GetBreakpointList(max int) (int32, []BreakPoint, error) {
    var numbps int32

    // 方法 (1): 使用 _Ctype_T32_Breakpoint
    // bps := make([]_Ctype_T32_Breakpoint, max)
    // code, err := C.T32_GetBreakpointList((*C.int)(&numbps), (*_Ctype_T32_Breakpoint)(unsafe.Pointer(&bps[0])), C.int(max))

    // 方法 (2): 使用 C.struct_T32_Breakpoint
    bps := make([]C.struct_T32_Breakpoint, max)
    // 编译错误: cannot use (*[0]byte)(unsafe.Pointer(&bps[0])) (type *[0]byte) as type *_Ctype_T32_Breakpoint in function argument
    code, err := C.T32_GetBreakpointList((*C.int)(&numbps), (*C.struct_T32_Breakpoint)(unsafe.Pointer(&bps[0])), C.int(max))

    if err != nil { /* ... */ }
    // ... 后续数据转换逻辑
    return 0, nil, nil
}

package t32

// #cgo linux,amd64 CFLAGS: -DT32HOST_LINUX_X64
// #cgo linux,386 CFLAGS: -DT32HOST_LINUX_X86
// #cgo windows,amd64 CFLAGS: -D_WIN64
// #cgo windows,386 CFLAGS: -D_WIN32
// #cgo windows CFLAGS: -fno-stack-check -fno-stack-protector -mno-stack-arg-probe
// #cgo windows LDFLAGS: -lkernel32 -luser32 -lwsock32
// #include "t32.h"
// #include <stdlib.h>
import "C"
import (
    "errors"
    "unsafe"
)

const (
    _INVALID_U64 = 0xFFFFFFFFFFFFFFFF
    _INVALID_S64 = -1
    _INVALID_U32 = 0xFFFFFFFF
    _INVALID_S32 = -1
    _INVALID_U16 = 0xFFFF
    _INVALID_S16 = -1
    _INVALID_U8  = 0xFF
    _INVALID_S8  = -1
)

type BreakPoint struct {
    Address uint32
    Enabled int8
    Type    uint32
    Auxtype uint32
}

func GetBreakpointList(max int) (int32, []BreakPoint, error) {
    var numbps int32

    // 正确方法: 使用 _Ctype_T32_Breakpoint 来创建数组
    bps := make([]_Ctype_T32_Breakpoint, max) // 这里的 _Ctype_T32_Breakpoint 是 Cgo 为 typedef T32_Breakpoint 生成的 Go 类型

    // 将 Go 数组的第一个元素的地址转换为 Cgo 期望的指针类型
    // C.T32_GetBreakpointList 期望 T32_Breakpoint*，Cgo 翻译为 *_Ctype_T32_Breakpoint
    code, err := C.T32_GetBreakpointList(
        (*C.int)(&numbps),
        (*_Ctype_T32_Breakpoint)(unsafe.Pointer(&bps[0])), // 强制类型转换，确保类型匹配
        C.int(max))

    if err != nil {
        return _INVALID_S32, nil, err
    } else if code != 0 {
        return _INVALID_S32, nil, errors.New("T32_GetBreakpointList Error")
    }

    if numbps > 0 {
        var gbps = make([]BreakPoint, numbps)
        for i := 0; i < int(numbps); i++ {
            gbps[i].Address = uint32(bps[i].address)
            gbps[i].Auxtype = uint32(bps[i].auxtype)
            gbps[i].Enabled = int8(bps[i].enabled)
            gbps[i].Type = uint32(bps[i]._type) // 注意 Cgo 会将 C 中的 type 字段转换为 _type 以避免与 Go 关键字冲突
        }
        return numbps, gbps, nil
    }
    return 0, nil, nil
}