在 C++/CLI 中包装非托管指针时堆损坏

我在使用本机 C 代码、C++/CLI 和 C# 的 .NET 应用程序中遇到了堆损坏问题。这是我第一次真正进入这里的杂草。

应用程序的结构是用于 GUI 和整体控制流的 C#、用于包装本机 C 函数的 C++/CLI，以及用于处理数据的本机 C 函数。这些本机 C 函数通常接受指向数组（例如：int*）和维度的本机指针作为输入。C++/CLI 将这些低级函数包装为更高级别的组合处理函数，C# 调用高级函数。

有时，我确实需要在 C# 级别分配非托管内存，然后将相同的内存包传递给几个不同的 C++/CLI 函数。

为了在 C# 和 C++/CLI 层中自由传递这些数组，我围绕托管指针创建了一个精简包装类。这个包装器称为ContiguousArray，在C++/CLI层定义，看起来像这样：

template <typename T>
public ref class ContiguousArray
{
public:
  ContiguousArray<T>(int size)
  {
    _size = size;
    p = (T*) calloc(_size,sizeof(T));
  }
  T& operator[](int i)
  {
    return p[i];
  }
  int GetLength()
  {
    return _size;
  }
  ~ContiguousArray<T>()
  {
    this->!ContiguousArray<T>();
  }
  !ContiguousArray<T>()
  {
    if (p != nullptr)
    {
      free(p);
      p = nullptr;
    }
  }
  T* p;
  int _size;
};
// Some non-templated variants of ContiguousArray for passing out to other .NET languages
public ref class ContiguousArrayInt16 : public ContiguousArray<Int16>
{
  ContiguousArrayInt16(int size) : ContiguousArray<Int16>(size) {}
};

我以几种方式使用这个包装类。

用例 1 （C++/CLI）：

{
  // Create an array for the low level code
  ContiguousArray<float> unmanagedArray(1024);
  // Call some native functions
  someNativeCFunction(unmanagedArray.p, unmanagedArray.GetLength());
  float* unmanagedArrayPointer = unmanagedArray.p;
  anotherNativeCFunction(unmanagedArrayPointer, unmanagedArray.GetLength());
  int returnCode = theLastNativeCFunction(unmanagedArray.p, unmanagedArray.GetLength());
  return returnCode;
} // unmanagedArray goes out of scope, freeing the memory

用例 2 （C++/CLI）：

{
  // Create an array for the low level code
  ContiguousArray<float>^ unmanagedArray = gcnew ContiguousArray<float>(1024);
  cliFunction(unmanagedArray);
  anotherCLIFunction(unmanagedArray);
  float* unmanagedArrayPointer = unmanagedArray->p;
  int returnCode = nativeFunction(unmanagedArrayPointer, unmanagedArray->GetLength());
  return returnCode;
} // unmanagedArray goes out of scope, the garbage collector will take care of it at some point

用例 3 （C#）：

{
  ContiguousArrayInt16 unmanagedArray = new UnmanagedArray(1024);
  cliFunction(unmanagedArray);
  unmanagedArray = anotherCLIFunctionThatReplacesUnmanagedArray(unmanagedArray); // Unmanaged array is possibly replaced, original gets collected at some point
  returnCode = finalCLIFunction(unmanagedArray);
  // Do something with return code like show the user
} // Memory gets freed at some point

我

以为我在这个包装类处理非托管内存时非常小心，但我在我的应用程序中不断看到堆损坏和访问冲突问题。 我从不保留指向 ContiguousArray 对象有效范围之外的非托管内存的本机指针。

从理论上讲，这三个用例中的任何一个都可能导致堆损坏，这有什么问题吗？我是否在我的连续阵列实现中缺少一些关键的东西？我担心垃圾收集器可能变得有点过分热心，并在我真正完成托管对象之前清理它们。

用例 1：我是否保证在右大括号之前不会调用终结器？是否有可能 .NET 已确定该对象不再使用，并且在我仍然有指向其内部存储器的指针时对其进行清理？GC：：KeepAlive 是否需要用于堆栈对象？

用例 2：我是否需要在末尾使用 GC：：KeepAlive 来保证在第三次函数调用之前不会释放对象？如果我改为写，我还需要它吗： nativeFunction（unmanagedArray->p， unmanagedArray->GetLength（））;

用例 3：我在这里看不出有什么问题，但也许我错过了什么？

{
  // Create an array for the low level code
  ContiguousArray<float>^ unmanagedArray = gcnew ContiguousArray<float>(1024);
  cliFunction(unmanagedArray);
  anotherCLIFunction(unmanagedArray);
  float* unmanagedArrayPointer = unmanagedArray->p;
  int returnCode = nativeFunction(unmanagedArrayPointer, unmanagedArray->GetLength());
  GC::KeepAlive(unmanagedArray); // Force the wrapper to stay alive while native operations finish.
  return returnCode;
}

int finalCLIFunction(ContiguousArrayInt16^ unmanagedArray)
{
  // Do a bunch of work with the unmanaged array
  Int16* ptr = unmanagedArray->p;
  for(int i=0; i < unmanagedArray->GetLength(); i++)
  {
    ptr[i]++;
  }
  // Call KeepAlive on the calling arguments to ensure they stay alive
  GC::KeepAlive(unmanagedArray);
  return 0;
}