c-指向2D动态数组指针的指针

Question

如何创建指向以下2D数组指针int**arr的指针。我正在寻找类似int***arr及其分配、释放、访问和使用的东西。

int main()
{
  int** arr;
  int row = 11;
  int col = 2;
  int i,j;
  arr = (int**)malloc(sizeof(int*)*row);
  for (i=0; i<row; ++i){
    arr[i] = (int*)malloc(sizeof(int)*col);
  }
  for (i = 0; i < row; i++) {
    for (j = 0; j < col; j++) {
        arr[i][j] = i;
        printf("arr[%d][%d] : %dn",i,j,arr[i][j]);
    }
  }
  return 0;
}

以前的参考文献：

动态2D数组指针：

C编程动态初始化2D阵列

指向动态2D数组的指针，但这里的解释是使用new关键字，我想使用malloc代替：

如何在C++中分配2D指针数组

其他信息：

考虑以下场景：

XYZ* arr[A][B];

"XYZ"是自定义数据类型，"A"&"B"是运行时的动态变量

在这种情况下，我们如何定义A&B，并使用CCD_ 3类型访问CCD_ 2元素值。

Answer 1

深入了解答案，您会发现更多可能的解决方案。

首先，我想向您介绍一个解决方案，在相同长度的列的情况下，使用1d指针管理动态2d数组。

#include <stdlib.h>
#include <stdio.h>
struct XYZ
{
    int someValue;
};
struct XYZ* GetArrayItem(struct XYZ* itemArray, int numCols, int row, int col)
{
    return &itemArray[row * numCols + col];
}
int main()
{
    int A = 5;
    int B = 4;
    struct XYZ* arr = (struct XYZ*)calloc(A*B, sizeof(struct XYZ));
    for (int i = 0; i < A; i++)
    {
        for (int j = 0; j < B; j++)
        {
            GetArrayItem(arr, B, i, j)->someValue = 1;
        }
    }
    free(arr);
    return 0;
}

对于不同长度的列，双指针可能是一个可行的解决方案。

struct XYZ
{
    int someValue;
};
int main()
{
    int i;
    int j;
    // row count
    int A = 5;
    // column count per row
    int B[] = { 3, 4, 3, 2, 4 };
    struct XYZ** arr = (struct XYZ**)calloc(A, sizeof(struct XYZ*));
    for (i = 0; i < A; i++)
    {
        // initialize column for each row
        arr[i] = (struct XYZ*)calloc(B[i], sizeof(struct XYZ));
    }
    for (i = 0; i < A; i++)
    {
        for (j = 0; j < B[i]; j++)
        {
            // access items
            arr[i][j].someValue = 1;
        }
    }
    for (i = 0; i < A; i++)
    {
        free(arr[i]);
    }
    free(arr);
    return 0;
}

然而，我建议您在需要2d数据的情况下创建一个更明确的对象结构。这使得设计更加明确，每行的列数也更加透明。

struct XYZ
{
    int someValue;
};
struct MyDomainSpecificRow
{
    int numColumns;
    struct XYZ* myRowData;
};
int main()
{
    int i;
    int j;
    // row count
    int A = 5;
    // column count per row
    int B[] = { 3, 4, 3, 2, 4 };
    // 1d array of rows, each containing 1d array of cells
    struct MyDomainSpecificRow* arr = (struct MyDomainSpecificRow*)calloc(A, sizeof(struct MyDomainSpecificRow));
    for (i = 0; i < A; i++)
    {
        // initialize column for each row
        arr[i].numColumns = B[i];
        arr[i].myRowData = (struct XYZ*)calloc(B[i], sizeof(struct XYZ));
    }
    for (i = 0; i < A; i++)
    {
        for (j = 0; j < arr[i].numColumns; j++)
        {
            // access items
            arr[i].myRowData[j].someValue = 1;
        }
    }
    for (i = 0; i < A; i++)
    {
        free(arr[i].myRowData);
    }
    free(arr);
    return 0;
}

Answer 2

解决方案：最后，我设法得到了我想要的东西。

声明：

NodeClass* currentNode;     //Single Pointer Declaration
NodeClass*** triplePtrNode; //Triple Pointer Declaration

定义&分配：

//row, col are dynamic values at runtime
//row memory allocation
triplePtrNode = (NodeClass***)malloc(sizeof(NodeClass)*row); 
for (i=0; i<row; ++i){
    //col memory allocation
    triplePtrNode[i] = (NodeClass**)malloc(sizeof(NodeClass)*col); 
}

用法：

for (i=0; i<memberCounts; ++i){
    *(*(triplePtrNode+i)+0) = currentNode->member1;
    *(*(triplePtrNode+i)+1) = currentNode->member2;
}