关于C#调用C++dll传指针释放内存问题

C# 调用 C++ DLL 传递指针并释放内存，需要注意以下事项：

1.确保 C++ DLL 使用标准的导出和导入约定，以免在调用时出现问题。

2.在 C++ DLL 中，应声明一个专用于释放内存的函数。

3.在 C# 中，需要使用 Marshaling 手动管理内存。

以下是一些实践指南：

1. 声明函数接口

需要在 C# 中与 C++ DLL 中的函数的名称、签名和特性一致。这可以通过声明一些函数接口来实现。例如：

[DllImport("DllName.dll", CallingConvention = CallingConvention.Cdecl)]
public static extern int FuncName(ref IntPtr pParam);

各个参数的作用如下：

• DllName.dll：C++ DLL 的名称。
• CallingConvention.Cdecl：调用约定，此处为 CDECL。
• FuncName：C++ DLL 中的函数名。

• ref IntPtr pParam：可传递指针的参数。

• 在 C++ 中实现释放内存的函数

为了允许 C# 释放 C++ memory，需要在 C++ DLL 中实现一个专门用于释放内存的函数。这个函数的名字可以称作“FreeMemory”:

extern "C" void __stdcall FreeMemory(void* pParam) {
    if (pParam) {
        delete pParam;
        pParam = nullptr;
    }
 }

需要注意以下事项：

• 函数的名称必须在 C# 中也定义为“FreeMemory”。
• 函数必须声明为 extern "C"，以确保它使用标准的 C 导出约定。
• 函数必须包含 __stdcall 表示符，以告知编译器使用标准的调用约定。
• 函数需要对给定的指针进行释放操作。

需要特别注意的是，如果 C++ DLL 的活动内容包括创建对象，那么在 C++ DLL 中实现一个与 C# 中 Dispose 模式类似的清理部分是非常有用的。

1. 在 C# 中实现内存管理

在 C# 中，需要使用 Marshaling 手动管理内存。这可以通过使用 Marshal.AllocHGlobal、Marshal.StructureToPtr、Marshal.PtrToStructure、Marshal.FreeHGlobal 等方法来实现。例如：

public static int CallFunc(IntPtr pParam) {
    SomeStruct someStruct = new SomeStruct();
    Marshal.PtrToStructure(pParam, someStruct);

    //Do something with `someStruct` here

    IntPtr ptr = Marshal.AllocHGlobal(sizeof(SomeStruct));
    Marshal.StructureToPtr(someStruct, ptr, false);

    return FuncName(ref ptr);
}

private static void FreeMemory(IntPtr pParam) {
    if (pParam != IntPtr.Zero) {
        FreeMemory(pParam);
        Marshal.FreeHGlobal(pParam);
    }
}

在此示例中，假设在 C++ DLL 中也使用了同样的数据结构： SomeStruct。该类型的定义需要在 C++ 和 C# 中都一致。在 CallFunc 函数中，使用 PtrToStructure 将指针转换为 SomeStruct。此后，使用 Marshal.AllocHGlobal 为 C++ DLL 中的函数分配内存。请注意，Marshal.EraseOverloadRecord 处于安全考虑而没有开启。

在执行完方法后，需要为内存释放空间。当函数返回准备释放时，可以调用 C++ DLL 中的 FreeMemory 函数，该函数会释放之前分配的空间。

在执行函数时，应注意所有的引用都应强制使用 try/finally 块，以确保在发生异常时也能正确清理内存。

另一个示例：

[DllImport(@"c:\mydll.dll", CallingConvention = CallingConvention.Cdecl)]
unsafe public static extern void DoFreeMemory(byte * ptr);

[StructLayout(LayoutKind.Sequential)]
public struct MyStruct
{
        public byte byte1;
        public byte byte2;
        public byte byte3;
        public byte byte4;
}

[StructLayout(LayoutKind.Sequential)]
public unsafe struct Memory
{
        public MyStruct *ptr;
        public int length;
}

void Example()
{
    IntPtr pMemory = Marshal.AllocHGlobal(sizeof(MyStruct) * 5); //5 struct array
    Memory data = new Memory
    {
        ptr = (MyStruct*)pMemory.ToPointer(),
        length = 5
    };

    for (int i = 0; i < data.length; i++)
    {
        data.ptr[i].byte1 = (byte)i;
        data.ptr[i].byte2 = (byte)(i + 1);
        data.ptr[i].byte3 = (byte)(i + 2);
        data.ptr[i].byte4 = (byte)(i + 3);
    }

    IntPtr pData = Marshal.AllocHGlobal(sizeof(Memory));
    Marshal.StructureToPtr(data, pData, false);

    DoFreeMemory((byte*)pData.ToPointer());

    Marshal.FreeHGlobal(pMemory);
    Marshal.FreeHGlobal(pData);
}

在该示例中， C++ DLL 需要按以下方式分配和释放内存：

extern "C" {
    struct MemStruct {
        MyStruct *ptr;
        int length;
    };

    __declspec(dllexport) void __stdcall DoFreeMemory(byte * ptr) {
        MemStruct* pData = reinterpret_cast<MemStruct*>(ptr);
        delete[] pData->ptr;
        delete[] pData;
    }
}

首先，为“Memory”类型创建一个结构体。在此数据结构中，包含了必要的指针和数据长度。然后，为 C++ DLL 函数的使用准备好指针，并且在使用数据时可以将指针转换为指向数据结构的指针。最后，使用释放数据指针的方法， DoFreeMemory，释放内存。

这就是调用 C++ DLL 时的指针传递及内存释放所需的基本步骤。如有必要，可以根据不同的代码结构和内存解除要求进行调整或修改。