c编程中递归函数更新动态列和行大小的2D数组

在c编程中，我通过列和行的大小来扩展2D数组

#include <stdio.h>
#include <malloc.h>
//#include <conio.h>
//#include <stdlib.h>

void func(int** p, int d, int** sizes)
{
    static int count = 0;
    int* item = NULL;
    int* temp = NULL;
    if (d == 5) return;
    *sizes = (int*) realloc(*sizes, (d + 1) * sizeof(*sizes));
    *sizes[count] = d + 1; // <=== in second recursive call it throws memory allocation errors here in runtime 

    //p = (int**) realloc(p, (count + 1) * sizeof(int*));

    //printf("%d\n", *sizes[count]);

    //item = (int*) realloc(*(p + d) , *sizes[count] * sizeof(int));
    //if (item) *(p + *sizes[count]) = item;

    ++count;
    func(p, d + 1, sizes);
}

int main()
{
    int* sizes = (int*) malloc(sizeof(int)); // different column sizes of rows
    int** p = (int**) malloc(sizeof(int*));
    *p = (int*) malloc(sizeof(int));
    printf("Hello World!\n");
    func(p, 0, &sizes);
    printf("Hello End!\n");
    getchar();
    free(p);
    return 0;
}

#包括
#包括
//#包括
//#包括
无效函数（整数**p、整数d、整数**大小）
{
静态整数计数=0；
int*item=NULL；
int*temp=NULL；
如果（d==5）返回；
*尺寸=（int*）realloc（*尺寸，（d+1）*尺寸（*尺寸））；
*size[count]=d+1；//此处的
*size[count]
与您期望的内容无关。运算符优先级首先是
size[count]
，然后才应用
*
运算符。要获得您期望的内容，必须使用：

（*大小）[计数]=d+1；

如果您想重复使用，这也必须应用于您的评论部分。
如果您都想知道我的最终结果是什么，那么：

#include <stdio.h>
#include <malloc.h>
//#include <conio.h>
//#include <stdlib.h>

struct ARR
{
    int** p;
};

void __cdecl func(struct ARR* arr, int d, int** sizes, int* rows)
{
    int* item = NULL;
    int iCol = 0;
    if (d == 5) return;

    *sizes = (int*) realloc(*sizes, (d + 1) * sizeof(*sizes));

    (*sizes)[*rows] = d + 1;
    printf("%d=>%d\n", *rows, (*sizes)[*rows]);

    arr->p = (int**) realloc(arr->p, (*rows + 1) * sizeof(int*));

    item = (int*) malloc(sizeof(int));
    item = (int*) realloc(item , (*sizes)[*rows] * sizeof(int));
    if (item) *(arr->p + *rows) = item;

    iCol = (*sizes)[*rows] - 1;
    arr->p[*rows][iCol] = 1;
    printf("item[%d][%d]: %d\n", *rows, iCol, arr->p[*rows][iCol]);
    ++(*rows);
    func(arr, d + 1, sizes, rows);
}

int main()
{
    int rows = 0, i = 0, j = 0;
    struct ARR arr;
    int* sizes = (int*) malloc(sizeof(int));
    arr.p = (int**) malloc(sizeof(int*));

    *(arr.p) = (int*) malloc(sizeof(int));

    printf("Hello World!\n");
    func(&arr, 0, &sizes, &rows);
    printf("Hello End!\n");

    for (; i < rows; ++i)
    {
        int j = sizes[i] - 1;
        printf("p[%d][%d]=%d\n", i, j, arr.p[i][j]);
    }

    for (; i < rows; ++i)
    {
        int j = sizes[i] - 1;       
        free(arr.p[i]);
        arr.p[i] = NULL;
    }
    free(arr.p);
    free(sizes);

    getchar();
    return 0;
}

#包括
#包括
//#包括
//#包括
结构ARR
{
int**p；
};
void\uu cdecl func（结构ARR*ARR，int d，int**大小，int*行）
{
int*item=NULL；
int-iCol=0；
如果（d==5）返回；
*尺寸=（int*）realloc（*尺寸，（d+1）*尺寸（*尺寸））；
（*尺寸）[*行]=d+1；
printf（“%d=>%d\n”，*行，（*大小）[*行]；
arr->p=（int**）realloc（arr->p，（*行+1）*sizeof（int*）；
项目=（int*）malloc（sizeof（int））；
item=（int*）realloc（item，（*大小）[*行]*sizeof（int））；
如果（项目）*（arr->p+*行）=项目；
iCol=（*大小）[*行]-1；
arr->p[*行][iCol]=1；
printf（“项目[%d][%d]：%d\n”，*行，iCol，arr->p[*行][iCol]）；
++（*行）；
func（arr，d+1，大小，行）；
}
int main（）
{
int行=0，i=0，j=0；
结构ARR-ARR；
int*大小=（int*）malloc（sizeof（int））；
arr.p=（int**）malloc（sizeof（int*）；
*（arr.p）=（int*）malloc（sizeof（int））；
printf（“你好，世界！\n”）；
func（&arr，0，&size，&rows）；
printf（“你好，结束！\n”）；
对于（；i<行；++i）
{
int j=尺寸[i]-1；
printf（“p[%d][%d]=%d\n”，i，j，arr.p[i][j]）；
}
对于（；i<行；++i）
{
int j=尺寸[i]-1；
免费（arr.p[i]）；
arr.p[i]=NULL；
}
免费（arr.p）；
免费（尺寸）；
getchar（）；
返回0；
}

我希望许多程序员都能从这次讨论中得到有价值的帮助。
运行时会收到什么错误消息？是编译器错误还是segfault？请更清楚一点。为什么要使用递归？@chqrlieforyellowblockquotes我在上面编辑时提到了我的原因。@Aplet123我在屏幕截图中添加了错误消息@TajuddinKhandaker:您的编辑没有解释递归方法的必要性。感谢您指出问题所在。请检查我的编辑好吗？存在递归时，我无法访问数组。一些观察：。最好避免在
malloc（）中使用
sizeof
的显式类型
，改为使用表达式：
int*size=（int*）malloc（sizeof（int））
-->

int*size=malloc（sizeof*size）。这不太容易出错，更容易维护，通常更容易阅读。

item=（int*）malloc（sizeof（int））；

-只需

item=NULL

。与

size=NULL

和

arr.p=NULL

相同

realloc

需要已分配或空的指针。无需为realloc预分配指针。切勿使用

realloc（）

直接；始终将结果存储在临时变量中，并检查分配是否成功。如果调用

realloc（）

失败，则直接分配将失去对原始内存的访问，这是内存泄漏。但是，在上述代码中，无需先

malloc（）

再调用

realloc（））

立即：。此外，通常，始终检查任何

malloc（）

或

realloc（）

以确保分配成功。

#include <stdio.h>
#include <malloc.h>
//#include <conio.h>
//#include <stdlib.h>

struct ARR
{
    int** p;
};

void __cdecl func(struct ARR* arr, int d, int** sizes, int* rows)
{
    int* item = NULL;
    int iCol = 0;
    if (d == 5) return;

    *sizes = (int*) realloc(*sizes, (d + 1) * sizeof(*sizes));

    (*sizes)[*rows] = d + 1;
    printf("%d=>%d\n", *rows, (*sizes)[*rows]);

    arr->p = (int**) realloc(arr->p, (*rows + 1) * sizeof(int*));

    item = (int*) malloc(sizeof(int));
    item = (int*) realloc(item , (*sizes)[*rows] * sizeof(int));
    if (item) *(arr->p + *rows) = item;

    iCol = (*sizes)[*rows] - 1;
    arr->p[*rows][iCol] = 1;
    printf("item[%d][%d]: %d\n", *rows, iCol, arr->p[*rows][iCol]);
    ++(*rows);
    func(arr, d + 1, sizes, rows);
}

int main()
{
    int rows = 0, i = 0, j = 0;
    struct ARR arr;
    int* sizes = (int*) malloc(sizeof(int));
    arr.p = (int**) malloc(sizeof(int*));

    *(arr.p) = (int*) malloc(sizeof(int));

    printf("Hello World!\n");
    func(&arr, 0, &sizes, &rows);
    printf("Hello End!\n");

    for (; i < rows; ++i)
    {
        int j = sizes[i] - 1;
        printf("p[%d][%d]=%d\n", i, j, arr.p[i][j]);
    }

    for (; i < rows; ++i)
    {
        int j = sizes[i] - 1;       
        free(arr.p[i]);
        arr.p[i] = NULL;
    }
    free(arr.p);
    free(sizes);

    getchar();
    return 0;
}