Динамический c столбец и двумерный массив размера строки обновлены в рекурсивной функции в c программировании

Question

Я увеличиваю двумерный массив по размеру столбца и строки в c программировании.

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

Но я застрял в ошибках выделения памяти. Кто-нибудь, пожалуйста, помогите? Я неправильно использую reallo c ()? пожалуйста, укажите мои ошибки. На самом деле я собирался решить проблему на leetcode.com, где мне потребовался двумерный массив с переменным размером столбца в c программировании. Таким образом, я думал, что этот мозговой штурм поможет мне сначала понять динамический массив c 2D. Тогда я перейду к реальной проблеме.

РЕДАКТИРОВАТЬ:

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

void __cdecl func(int** p, int d, int** sizes, int* rows)
{
    int* item = NULL;
    if (d == 5) return;
    *sizes = (int*) realloc(*sizes, (d + 1) * sizeof(*sizes));
    (*sizes)[*rows] = d + 1;

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

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

    item = (int*) malloc((*sizes)[*rows] * sizeof(int));
    item = (int*) realloc(item , (*sizes)[*rows] * sizeof(int));

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

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

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

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

    for (; i < rows; ++i)
    {
        int j = sizes[i] - 1;
        printf("p[%d][%d]\n", i, j, p[i][j]); // CAN'T ACCESS HERE
    }

    //for (; i < rows; ++i)
    //{
    //  if (*(p + i))
    //  {
    //      free(*(p + i));
    //      *(p + i) = NULL;
    //  }
    //}
    //free(p);
    //free(sizes);

    getchar();
    return 0;
}

Я не могу получить доступ к массиву, когда рекурсивная функция завершает выполнение. Я напечатал диагональные значения двумерного массива только при неправильной рекурсии. Но снаружи он показывает нарушение доступа.

Answer 1

*sizes[count] не относится к тому, что вы ожидаете здесь. Приоритет оператора - сначала size[count], только затем применяется оператор *. Чтобы получить то, что вы ожидаете, вы должны будете использовать:

    (*sizes)[count] = d + 1;

, и это также должно применяться к вашим закомментированным частям, если вы хотите использовать их снова.

Answer 2

Если вам всем любопытно, каким был мой окончательный результат, вот он:

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

Я надеюсь, что многие программисты получат ценную помощь в этом обсуждении.