嘿，这个问题在C#和C的跨语言互操作中挺常见的，我来一步步给你拆解解决：

首先要明确：绝对不能用栈内存分配数组，因为栈内存会在函数返回后被销毁，C#拿到的会是无效指针。必须用堆内存，而且要选C#能安全释放的方式，这里有两种常用方案：

方案1：使用COM堆分配（CoTaskMemAlloc） #

这种方式分配的内存，C#可以直接用Marshal.FreeCoTaskMem释放，不需要C端额外提供释放函数：

#include <objbase.h> // 引入CoTaskMemAlloc的头文件

struct MyStruct {
    int *arr;
    int size;
};

// 导出供C#调用的函数
__declspec(dllexport) MyStruct GetMyStruct() {
    MyStruct result;
    result.size = 5; // 这里可以根据业务逻辑动态设置大小
    // 分配内存，大小是数组元素个数*int字节数
    result.arr = (int*)CoTaskMemAlloc(result.size * sizeof(int));
    
    // 一定要检查分配是否成功
    if (result.arr == NULL) {
        result.size = 0;
        return result;
    }
    
    // 给数组赋值（示例逻辑）
    for (int i = 0; i < result.size; i++) {
        result.arr[i] = i * 10;
    }
    return result;
}

方案2：提供专门的释放函数（更推荐） #

如果后续结构体有改动，或者你想把内存管理逻辑统一放在C端，这种方式更灵活安全。用标准的malloc分配，然后导出一个释放函数：

#include <stdlib.h>

struct MyStruct {
    int *arr;
    int size;
};

__declspec(dllexport) MyStruct GetMyStruct() {
    MyStruct result;
    result.size = 5;
    result.arr = (int*)malloc(result.size * sizeof(int));
    
    if (result.arr == NULL) {
        result.size = 0;
        return result;
    }
    
    for (int i = 0; i < result.size; i++) {
        result.arr[i] = i * 10;
    }
    return result;
}

// 导出释放函数，C#调用它来释放内存
__declspec(dllexport) void FreeMyStruct(MyStruct *obj) {
    if (obj != NULL && obj->arr != NULL) {
        free(obj->arr);
        obj->arr = NULL; // 防止野指针
        obj->size = 0;
    }
}

C#需要用StructLayout来保证结构体字段的顺序和C端一致，用IntPtr来封送C的指针类型，然后把非托管数组复制到托管数组使用。

对应方案1的C#实现 #

using System;
using System.Runtime.InteropServices;

// 保证结构体布局和C端完全一致
[StructLayout(LayoutKind.Sequential)]
public struct MyStruct
{
    public IntPtr arr; // 对应C的int*
    public int size;   // 对应C的int size
}

// 声明原生DLL的导入函数
public class NativeMethods
{
    // 替换成你的DLL文件名，调用约定要和C端一致（这里是Cdecl）
    [DllImport("YourNativeLibrary.dll", CallingConvention = CallingConvention.Cdecl)]
    public static extern MyStruct GetMyStruct();
}

// 使用示例
class Program
{
    static void Main()
    {
        MyStruct myStruct = NativeMethods.GetMyStruct();
        
        if (myStruct.size > 0 && myStruct.arr != IntPtr.Zero)
        {
            // 把非托管内存的数组复制到托管数组
            int[] managedArray = new int[myStruct.size];
            Marshal.Copy(myStruct.arr, managedArray, 0, myStruct.size);
            
            // 这里可以使用托管数组做业务逻辑
            Console.WriteLine("Received array elements:");
            foreach (int num in managedArray)
            {
                Console.WriteLine(num);
            }
            
            // 释放C端用CoTaskMemAlloc分配的内存
            Marshal.FreeCoTaskMem(myStruct.arr);
        }
    }
}

对应方案2的C#实现 #

这里需要调用C端提供的释放函数，并且用finally块确保内存一定会被释放：

using System;
using System.Runtime.InteropServices;

[StructLayout(LayoutKind.Sequential)]
public struct MyStruct
{
    public IntPtr arr;
    public int size;
}

public class NativeMethods
{
    [DllImport("YourNativeLibrary.dll", CallingConvention = CallingConvention.Cdecl)]
    public static extern MyStruct GetMyStruct();
    
    // 导入释放函数，注意用ref传递结构体
    [DllImport("YourNativeLibrary.dll", CallingConvention = CallingConvention.Cdecl)]
    public static extern void FreeMyStruct(ref MyStruct obj);
}

class Program
{
    static void Main()
    {
        MyStruct myStruct = NativeMethods.GetMyStruct();
        
        try
        {
            if (myStruct.size > 0 && myStruct.arr != IntPtr.Zero)
            {
                int[] managedArray = new int[myStruct.size];
                Marshal.Copy(myStruct.arr, managedArray, 0, myStruct.size);
                
                Console.WriteLine("Received array elements:");
                foreach (int num in managedArray)
                {
                    Console.WriteLine(num);
                }
            }
        }
        finally
        {
            // 无论是否发生异常，都要调用释放函数
            NativeMethods.FreeMyStruct(ref myStruct);
        }
    }
}

• 调用约定必须一致：如果C端函数用__stdcall（比如Windows API常用的），C#的DllImport要改成CallingConvention = CallingConvention.StdCall，否则会导致栈不平衡崩溃。
• 一定要处理内存分配失败：C端要检查malloc/CoTaskMemAlloc的返回值，C端也要判断size和arr是否有效，避免空指针异常。
• 不要直接操作非托管指针：尽量用Marshal.Copy把非托管数组复制到托管数组，除非你用不安全代码（不推荐，会增加内存泄漏风险）。

内容的提问来源于stack exchange，提问作者AndersG