在 C# 中从交错数组转换为双指针

Question

这里有一个简单的问题：有没有办法从锯齿状数组转换为双指针？

例如，将 double[][] 转换为 double**

不幸的是，这不能仅通过强制转换来完成（就像在普通的旧 C 中一样）。 使用 fixed 语句似乎也无法解决问题。 在 C# 中是否有任何（最好是尽可能有效的）方法来完成此任务？ 我怀疑解决方案可能根本不是很明显，尽管我仍然希望有一个简单的解决方案。

Answer 1

一点安全感。
正如第一个解决方案的评论中提到的，嵌套数组可以移动，因此也应该固定它们。

unsafe
{
    double[][] array = new double[3][];
    array[0] = new double[] { 1.25, 2.28, 3, 4 };
    array[1] = new double[] { 5, 6.24, 7.42, 8 };
    array[2] = new double[] { 9, 10.15, 11, 12.14 };

    GCHandle[] pinnedArray = new GCHandle[array.Length];
    double*[] ptrArray = new double*[array.Length];

    for (int i = 0; i < array.Length; i++)
    {
        pinnedArray[i] = GCHandle.Alloc(array[i], GCHandleType.Pinned);
    }

    for (int i = 0; i < array.Length; ++i)
    {
        // as you can see, this pointer will point to the first element of each array
        ptrArray[i] = (double*)pinnedArray[i].AddrOfPinnedObject();
    }

    // here is your double**
    fixed(double** doublePtr = &ptrArray[0])
    {
        Console.WriteLine(**doublePtr);
    }

    // unpin all the pinned objects,
    // otherwise they will live in memory till assembly unloading
    // even if they will went out of scope
    for (int i = 0; i < pinnedArray.Length; ++i)
        pinnedArray[i].Free();
}

问题的简要说明：

当我们在堆上分配一些对象时，它们可能会在垃圾收集时被移动到另一个位置。 因此，想象一下接下来的情况：您已经分配了一些对象和内部数组，它们都放置在堆上的零代中。

现在，一些对象已经超出范围并成为垃圾，一些对象刚刚被分配。 垃圾收集器会将旧对象移出堆，并将其他对象移至更接近起始位置甚至下一代的位置，从而压缩堆。 结果将如下所示：

因此，我们的目标是将某些对象“固定”在堆中，这样它们就不会移动。
我们要达到这个目标需要什么？ 我们有已修复声明和GCHandle.Allocate 方法。

首先，GCHandle.Allocate 的作用是什么？ 它在内部系统表中创建新条目，该条目具有对作为参数传递给方法的对象的引用。 因此，当垃圾收集器检查堆时，他将检查内部表中的条目，如果找到条目，他会将对象标记为活动的，并且不会将其移出堆。 然后，他会看看这个对象是如何固定的，并且在压缩阶段不会移动内存中的对象。 fixed 语句的作用几乎相同，只是当您离开作用域时它会自动“取消固定”对象。

总结：每个被 fixed 固定的对象一旦离开范围就会自动“取消固定”。 在我们的例子中，它将在循环的下一次迭代中。

如何检查您的对象不会被移动或垃圾收集：只需消耗堆的所有预算进行零生成并强制 GC 压缩堆。 换句话说：在堆上创建很多对象。 在固定或“固定”物体后执行此操作。

for(int i = 0; i < 1000000; ++i)
{
    MemoryStream stream = new MemoryStream(10);
    //make sure that JIT will not optimize anything, make some work
    stream.Write(new Byte[]{1,2,3}, 1, 2);
}
GC.Collect();

小通知：有两种类型的堆——用于大对象和小对象。 如果你的对象很大，你应该创建大对象来检查你的代码，否则小对象不会强制GC开始垃圾收集和压缩。

最后，这里有一些示例代码，向任何感兴趣的人展示了使用未固定/未固定指针访问底层数组的危险。

namespace DangerousNamespace
{
    // WARNING!
    // This code includes possible memory access errors with unfixed/unpinned pointers!
    public class DangerousClass
    {
        public static void Main()
        {
            unsafe
            {
                double[][] array = new double[3][];
                array[0] = new double[] { 1.25, 2.28, 3, 4 };
                array[1] = new double[] { 5, 6.24, 7.42, 8 };
                array[2] = new double[] { 9, 10.15, 11, 12.14 };

                fixed (double* junk = &array[0][0])
                {
                    double*[] arrayofptr = new double*[array.Length];
                    for (int i = 0; i < array.Length; i++)
                        fixed (double* ptr = &array[i][0])
                        {
                            arrayofptr[i] = ptr;
                        }

                    for (int i = 0; i < 10000000; ++i)
                    {
                        Object z = new Object();
                    }
                    GC.Collect();

                    fixed (double** ptrptr = &arrayofptr[0])
                    {
                        for (int i = 0; i < 1000000; ++i)
                        {
                            using (MemoryStream z = new MemoryStream(200))
                            {
                                z.Write(new byte[] { 1, 2, 3 }, 1, 2);
                            }
                        }
                        GC.Collect();
                        // should print 1.25
                        Console.WriteLine(*(double*)(*(double**)ptrptr));
                    }
                }
            }
        }
    }
}

Answer 2

double[][] 是 double[] 的数组，而不是 double* 的数组，因此要获得 double** ，我们首先需要一个 double*[]

double[][] array = //whatever
//initialize as necessary

fixed (double* junk = &array[0][0]){

    double*[] arrayofptr = new double*[array.Length];
    for (int i = 0; i < array.Length; i++)
        fixed (double* ptr = &array[i][0])
        {
            arrayofptr[i] = ptr;
        }

    fixed (double** ptrptr = &arrayofptr[0])
    {
        //whatever
    }
}

我不禁想知道这是做什么用的以及是否有比需要双指针更好的解决方案。

Answer 3

我暂时使用了 zachrrs 解决方案（这是我怀疑可能需要首先完成的）。 这是一个扩展方法：

public static double** ToPointer(this double[][] array)
{
    fixed (double* arrayPtr = array[0])
    {
        double*[] ptrArray = new double*[array.Length];
        for (int i = 0; i < array.Length; i++)
        {
            fixed (double* ptr = array[i])
                ptrArray[i] = ptr;
        }

        fixed (double** ptr = ptrArray)
            return ptr;
    }
}