C#与C++交互开发系列（十）：数组传递的几种形式

前言

在C#和C++的交互开发中，数组传递是一个非常常见且实用的场景。数组可以作为方法的参数，也可以作为响应结果返回。在本篇博客中，我们将探讨几种常见的数组传递方式，展示如何在C#与C++之间进行有效的数据交换。我们将主要介绍以下几种方式：

作为参数传递数组
作为响应结果返回数组
多维数组的传递
结构体内嵌数组的传递

一、作为参数传递数组

在C#与C++交互中，数组可以作为参数传递给C++的原生函数。这里以一维数组为例，展示如何传递和接收。

1.1 C++函数定义

假设我们有一个接收整数数组的C++函数，函数将接收的数组中的每个元素加1。

cpp 复制代码

// C++函数定义
extern "C" __declspec(dllexport) void AddOneToEachElement(int* arr, int size) {
    for (int i = 0; i < size; i++) {
        arr[i] += 1;
    }
}

1.2 C#调用代码

在C#中，可以使用DllImport引入C++的DLL，并传递数组。

csharp 复制代码

using System;
using System.Runtime.InteropServices;

class Program
{
    // 引入C++的函数
    [DllImport("MyNativeLib.dll", CallingConvention = CallingConvention.Cdecl)]
    public static extern void AddOneToEachElement(int[] arr, int size);

    static void Main()
    {
        int[] numbers = { 1, 2, 3, 4, 5 };
        Console.WriteLine("原数组: " + string.Join(", ", numbers));

        // 调用C++函数
        AddOneToEachElement(numbers, numbers.Length);

        Console.WriteLine("处理后数组: " + string.Join(", ", numbers));
    }
}

1.3 结果

执行后，原数组的每个元素都会加1，输出结果如下：

原数组: 1, 2, 3, 4, 5
处理后数组: 2, 3, 4, 5, 6

这种方式非常直接，将C#的托管数组传递给C++的非托管代码时，数组的首地址以及数组的大小都需要传递给C++函数。

二、作为响应结果返回数组

C++可以返回一个数组给C#。通常，在C++中动态分配数组并返回给C#使用时，我们还需要提供释放内存的机制，避免内存泄漏。

2.1 C++函数定义

下面的例子展示如何在C++中分配一个整数数组，并返回给C#。还包括一个函数用于释放分配的内存。

cpp 复制代码

// C++函数定义
extern "C" __declspec(dllexport) int* CreateArray(int size) {
    int* arr = new int[size];
    for (int i = 0; i < size; i++) {
        arr[i] = i + 1;
    }
    return arr;
}

extern "C" __declspec(dllexport) void FreeArray(int* arr) {
    delete[] arr;
}

2.2 C#调用代码

在C#中，我们需要从C++获取数组并释放其内存。

csharp 复制代码

using System;
using System.Runtime.InteropServices;

class Program
{
    // 引入C++的函数
    [DllImport("MyNativeLib.dll", CallingConvention = CallingConvention.Cdecl)]
    public static extern IntPtr CreateArray(int size);

    [DllImport("MyNativeLib.dll", CallingConvention = CallingConvention.Cdecl)]
    public static extern void FreeArray(IntPtr arr);

    static void Main()
    {
        int size = 5;

        // 调用C++创建数组的函数
        IntPtr ptr = CreateArray(size);
        int[] managedArray = new int[size];

        // 将非托管内存的数组内容复制到托管数组中
        Marshal.Copy(ptr, managedArray, 0, size);

        Console.WriteLine("从C++返回的数组: " + string.Join(", ", managedArray));

        // 释放C++分配的内存
        FreeArray(ptr);
    }
}

2.3 结果

执行后，C++返回的数组将在C#中显示：

从C++返回的数组: 1, 2, 3, 4, 5

通过这种方式，C++可以将动态分配的数组返回给C#，同时提供释放内存的函数来避免内存泄漏。

三、多维数组的传递

在C++与C#的交互中，多维数组的传递较为复杂。通常可以将多维数组展平为一维数组进行传递，然后在接收端再将其转换回多维形式。

3.1 C++函数定义

假设我们要传递一个二维数组，可以在C++中将二维数组展平为一维数组进行处理。

cpp 复制代码

extern "C" __declspec(dllexport) void Process2DArray(int* arr, int rows, int cols) {
    for (int i = 0; i < rows; i++) {
        for (int j = 0; j < cols; j++) {
            arr[i * cols + j] += 1;
        }
    }
}

3.2 C#调用代码

在C#中可以将二维数组展平成一维数组，再调用C++函数。

csharp 复制代码

using System;
using System.Runtime.InteropServices;

class Program
{
    [DllImport("MyNativeLib.dll", CallingConvention = CallingConvention.Cdecl)]
    public static extern void Process2DArray(int[] arr, int rows, int cols);

    static void Main()
    {
        int[,] array2D = { { 1, 2 }, { 3, 4 } };
        int rows = array2D.GetLength(0);
        int cols = array2D.GetLength(1);

        // 将二维数组展平成一维数组
        int[] flatArray = new int[rows * cols];
        Buffer.BlockCopy(array2D, 0, flatArray, 0, flatArray.Length * sizeof(int));

        // 调用C++处理函数
        Process2DArray(flatArray, rows, cols);

        // 将一维数组转换回二维数组
        int[,] resultArray = new int[rows, cols];
        Buffer.BlockCopy(flatArray, 0, resultArray, 0, flatArray.Length * sizeof(int));

        // 输出结果
        for (int i = 0; i < rows; i++)
        {
            for (int j = 0; j < cols; j++)
            {
                Console.Write(resultArray[i, j] + " ");
            }
            Console.WriteLine();
        }
    }
}

3.3 结果

输出结果为：

2 3 
4 5

通过展平和还原二维数组，可以轻松传递复杂数组结构。

四、结构体内嵌数组的传递

有时我们会遇到结构体中包含数组的情况。C++与C#在传递结构体时需要保持一致的内存布局。

4.1 C++结构体定义

假设我们有一个包含内嵌数组的C++结构体，并且C++函数会处理此结构体：

cpp 复制代码

struct MyStruct {
    int values[5];
};

extern "C" __declspec(dllexport) void ProcessStruct(MyStruct* myStruct) {
    for (int i = 0; i < 5; i++) {
        myStruct->values[i] += 1;
    }
}

4.2 C#调用代码

在C#中，我们需要使用StructLayout来确保结构体的内存布局与C++匹配。

csharp 复制代码

using System;
using System.Runtime.InteropServices;

[StructLayout(LayoutKind.Sequential)]
struct MyStruct
{
    [MarshalAs(UnmanagedType.ByValArray, SizeConst = 5)]
    public int[] values;
}

class Program
{
    [DllImport("MyNativeLib.dll", CallingConvention = CallingConvention.Cdecl)]
    public static extern void ProcessStruct(ref MyStruct myStruct);

    static void Main()
    {
        MyStruct myStruct = new MyStruct { values = new int[] { 1, 2, 3, 4, 5 } };

        Console.WriteLine("原结构体数组: " + string.Join(", ", myStruct.values));

        // 调用C++函数
        ProcessStruct(ref myStruct);

        Console.WriteLine("处理后结构体数组: " + string.Join(", ", myStruct.values));
    }
}

4.3 结果

执行后，结构体内的数组每个元素都会加1，输出如下：

原结构体数组: 1, 2, 3, 4, 5
处理后结构体数组: 2, 3, 4, 5, 6

总结

在本篇博客中，我们讨论了C#与C++交互开发中数组传递的几种常见方式，包括数组作为参数传递和作为响应结果返回，以及如何处理多维数组和结构体内嵌数组。在实际开发中，正确处理数组的内存布局、传递方式以及跨语言边界的数据管理是至关重要的。以下是我们总结的几种方式的要点：

作为参数传递数组 ：通过DllImport可以直接传递C#托管数组到C++非托管代码中，通常需要传递数组的首地址和大小。对于一维数组，使用非常简单。
作为响应结果返回数组 ：C++函数可以动态分配数组并返回给C#，C#使用Marshal.Copy将非托管数组复制到托管数组中，此外必须提供相应的内存释放机制，避免内存泄漏。
多维数组的传递：多维数组可以展平为一维数组传递给C++，在C++端按行列处理，再在C#端将一维数组还原为多维形式。这种方式灵活且高效，适合处理较复杂的数组结构。
结构体内嵌数组的传递 ：在处理结构体中的数组时，确保C#和C++的内存布局一致非常重要。通过StructLayout和MarshalAs属性，C#可以准确传递和接收内嵌数组的结构体。

通过这几种方式，能够在C#与C++的互操作中高效处理各种形式的数组传递，确保两者之间的数据交换准确无误。在实际项目中，根据需求选择合适的数组传递方式，可以有效提升系统性能和开发效率。