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] : %d\n",i,j,arr[i][j]);
    }
  }

  return 0;
}

以前的参考资料：

动态2D数组指针：

C programming initialize 2D array dynamically

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

How to allocate a 2D array of pointers in C++

其他信息：

请考虑以下情况：

XYZ* arr[A][B];

＆＃34; XYZ＆＃34;是一种自定义数据类型，＆＃34; A＆＃34; ＆安培; ＆＃34; B＆＃34;是运行时的动态变量

在这种情况下，我们如何定义A＆amp; B在运行时使用arr[A][B]类型访问XYZ*元素值。

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

定义＆amp;分配

//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; }

指向2D动态阵列指针的指针

2 个答案: