C 指向二维动态数组指针的指针

如何创建指向以下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;
}

intmain（）
{
int**arr；
int行=11；
int col=2；
int i，j；
arr=（int**）malloc（sizeof（int*）*行）；
对于（i=0；i解决方案：
最后，我终于找到了我想要的东西

声明：

定义和分配：

//行、列是运行时的动态值
//行内存分配
三肽节点=（NodeClass***）malloc（sizeof（NodeClass）*行）；
对于（i=0；imember2；
}
在答案的后面，您可以找到更多可能的解决方案

首先，我想向您介绍一个解决方案，在相同长度列的情况下，使用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;
}

#包括
#包括
结构XYZ
{
int值；
};
结构XYZ*GetArrayItem（结构XYZ*itemArray，int numCols，int row，int col）
{
return&itemArray[row*numCols+col]；
}
int main（）
{
INTA=5；
int B=4；
struct XYZ*arr=（struct XYZ*）calloc（A*B，sizeof（struct XYZ））；
for（int i=0；isomeValue=1；
}
}
免费（arr）；
返回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;
}

struct XYZ
{
int值；
};
int main（）
{
int i；
int j；
//行数
INTA=5；
//每行的列计数
int B[]={3,4,3,2,4}；
结构XYZ**arr=（结构XYZ**）calloc（A，sizeof（结构XYZ*））；
对于（i=0；i

但是，我建议您在需要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;
}

struct XYZ
{
int值；
};
结构MyDomainSpecificRow
{
国际数列；
结构XYZ*myRowData；
};
int main（）
{
int i；
int j；
//行数
INTA=5；
//每行的列计数
int B[]={3,4,3,2,4}；
//1d行数组，每个行包含1d单元格数组
struct MyDomainSpecificRow*arr=（struct MyDomainSpecificRow*）calloc（A，sizeof（struct MyDomainSpecificRow））；
对于（i=0；i
对于指向
arr
的指针，您需要成为一个，被调用通常不是一种恭维。什么是“动态数组”？在动态内存中分配的数组或具有随时可能更改的可变维度的数组？正确答案在很大程度上取决于您想要哪一个。如果您只是想动态分配2D数组，那么它应该是
int（*arr）[row]=malloc（sizeof（int[col][row]）
就是这样。不需要指向指针的指针指向指向指针的指针…为什么需要三星指针？使用三星指针要解决的实际问题是什么？如果需要数组的动态数组（指针指向指针）你已经需要它了。为什么你需要增加另一个间接的水平？请在这个问题中找到额外的附加信息。C或C++中没有三个指针的正确用法。它们只在树星编程的分支中有用。而不是试图成为树星程序员，你应该集中精力解决实际的问题。em.您很有可能为任务选择了错误的解决方案。是的，我同意。我想在您的评论中添加以下内容：MISRA-C:2004 17.5“对象声明应包含不超过2级的指针间接寻址”MISRA C++ 2008 5-0 19对象的声明不应包含两个指针的间接级别。使用一维数组指针的二维数组比1D数组的效率低得多，并且有一些算法可以进行正确的索引。也不能保证内存将被连续地存储，这可能是一个问题。好。
#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;
}

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