前言

前面我们探讨了三种C#与C++交互的函数传递的三种形式：

1. C#与C++交互开发系列之函数参数传递之值传递
2. C#与C++交互开发系列之函数参数传递之引用传递
3. C#与C++交互开发系列值函数参数传递之指针传递

这些都是比较常见的内容，比较容易理解，但是实际开发过程中，比较往往存在较为复杂的结构传参，传递的参数类型多，基础类型和指针混用，复杂指针嵌套，传递数据量大等等。今天 我们一起探讨部分复杂类型传递参数的解析办法。

C++端代码

首先我们声明一个较为常见的结构：结构体TagPoint是基础类型的组装，表示单点。结构体TagPointList是点列表，包括了点的数量和指向点数组的指针。

typedef struct TagPoint {
	int Id;
	int X;
	int Y;
	int Z;
} Point;
typedef Point* LP_Point; //是指向 Point 结构体的指针类型，可以用于引用和操作一个点的数据
typedef const Point* LPC_Point; //是指向常量 Point 结构体的指针类型，用于指向不可修改的点数据

typedef struct TagPointList
{
	int Count;
	LP_Point Points; //指向 Point 结构体数组的指针，用于存储多个点的数据
} PointList;
typedef PointList* LP_PointList; //是指向 PointList 结构体的指针类型，可以用于引用和操作一个点列表的数据
typedef const PointList* LPC_PointList; //是指向常量 PointList 结构体的指针类型，用于指向不可修改的点列表数据。

声明函数：

/// <summary>
/// 申请堆内存空间
/// </summary>
/// <param name="ppData">使用对象双指针</param>
/// <returns></returns>
API int GetHeapPoints(Point** ppData);

/// <summary>
/// 释放堆内存空间
/// </summary>
/// <param name="pData"></param>
API void FreeHeapPoints(Point* pData);

声明定义了一个函数 GetHeapPoints，从堆内存中获取点数据，注意其中：Point** ppData 是函数的参数，它是一个指向指针的指针，表示该函数将会修改指针 ppData 所指向的指针的值。由于参数是一个指向指针的指针，这意味着函数会动态分配内存来存储点数据，并将分配的内存地址通过 ppData 返回给调用者。

声明定义一个函数 FreeHeapPoint。主要用来释放动态分配的点数据指针。

//申请堆空间存储10万随机点数据
int GetHeapPoints(Point** ppData)
{
	int size = 100000;
	*ppData = reinterpret_cast<Point*>(HeapAlloc(GetProcessHeap(), 0, size * sizeof(Point)));
	if (*ppData == nullptr) {
		// 处理内存分配失败的情况
		return 0;
	}
	srand(static_cast<unsigned int>(time(NULL)));
	for (int i = 0; i < size; ++i) {
		(*ppData)[i].Id = i;
		(*ppData)[i].X = rand() % 100;
		(*ppData)[i].Y = rand() % 100;
		(*ppData)[i].Z = rand() % 100;
	}
	return size;
}

//释放堆空间
void FreeHeapPoints(Point* pData)
{
	HeapFree(GetProcessHeap(), 0, pData);
}

C#端代码

首先定义和C++端相同的结构体，不同的是，PointList中Points是一个IntPtr结构，使用 IntPtr 类型来表示非托管资源的句柄或指针。

 // 定义 Point 结构体
 [StructLayout(LayoutKind.Sequential)]
 public struct PointList
 {
     public int Count;
     public IntPtr Points;
 }

 // 定义 Point 结构体
 [StructLayout(LayoutKind.Sequential)]
 public struct Point
 {
     public int Id;
     public int X;
     public int Y;
     public int Z;
 }

考虑到我们GetHeapPoints函数的参数是一个指向指针的指针 Point** ppData，它会修改指针 ppData 指向的地址，因此在 C# 中需要使用 IntPtr 来处理这种指针的交互。out关键字告诉编译器这个参数是一个输出参数，即它是用来从函数内部传递数据到调用者的。可以声明为：

[DllImport("CppLibrary.dll", CallingConvention = CallingConvention.Cdecl)]
 public static extern int GetHeapPoints(out IntPtr ppData);

 [DllImport("CppLibrary.dll", CallingConvention = CallingConvention.Cdecl)]
 public static extern void FreeHeapPoints(IntPtr ppData);

实现代码如下：

private static void GetHeapPoints()
{
    Console.WriteLine("-------------------------------GetHeapPoints----------------------------");
    Stopwatch stopwatch = new Stopwatch();
    stopwatch.Start();
    int dataSize = CppLibraryWapper.GetHeapPoints(out IntPtr ppData);
    if (dataSize > 0)
    {
        Point[] points = new Point[dataSize];
        for (int i = 0; i < dataSize; i++)
        {
            IntPtr ptr = IntPtr.Add(ppData, i * Marshal.SizeOf(typeof(Point)));
            points[i] = Marshal.PtrToStructure<Point>(ptr);
        }
        CppLibraryWapper.FreeHeapPoints(ppData);

        // 打印前10个 Point 数据
        Console.WriteLine("Data size: " + dataSize + "  " + stopwatch.ElapsedMilliseconds + "ms");
        Console.WriteLine("First 10 points:");
        for (int i = 0; i < 10; i++)
        {
            Console.WriteLine("Id: " + points[i].Id + ", X: " + points[i].X + ", Y: " + points[i].Y + ", Z: " + points[i].Z);
        }
    }
    stopwatch.Stop();
}

调用`
CppLibraryWapper.GetHeapPoints(out IntPtr ppData)`来获取指向`Point`数据的指针。使用`Marshal.PtrToStructure<Point>(ptr)`将内存中的指针`ptr`转换为`Point`结构体。通过循环遍历每个`Point`的指针并进行转换，将所有`Point`数据转换为`Point`数组`points`。调用`
CppLibraryWapper.FreeHeapPoints(ppData)`释放从C++库中获取的内存。

运行结果

完成上述代码，我们可以得到结果。正确解析数据。

我们加入循环调用，查看内存分配情况：通过观察诊断工具，发现内存维持在一个较好的水平。

如果我们把内存释放的代码注释掉，或者忘记编写释放内存调用。那么会出现非托管内存的暴增，直到我们的系统崩溃掉，

所以，在我们编写相关代码时，要非常注意内存的管理。

总结

C#与C++交互开发中的复杂类型传递与解析涉及多个方面，包括使用 P/Invoke 进行跨语言调用、正确处理指针和内存管理，以及确保正确的数据类型转换和数据解析。

上面还留有一个结构体TagPointList。后续我们会进行更复杂的嵌套指针的传递和解析的分析，如果你感兴趣的话，欢迎留言交流。

如果本文对你有帮助，我将非常荣幸。

如果你对复杂类型的传递和解析有自己的见解，欢迎留言交流。

如果你喜欢我的文章，谢谢三连，点赞，关注，转发吧！！！

#头条创作挑战赛# #记录我的2024# #编程经验# #自律学习计划#