c 为循环中的二维指针数组分配空间

Question

I have a rather large program that requires me to use pointers to 2 dimensional arrays. I'm having a difficult time allocating space for the arrays.

I've already tried allocating the space at the time of declaration but I ran into a million road blocks.

I found code here: Create a pointer to two-dimensional array

I have a 2D array of pointers to an array other_arrays

I have this:

    static double other_arrays[51][1];
    double (*SumH)[51][1] = &other_arrays;
    double (*WeightIH)[51][1] = &other_arrays;
    double (*Hidden)[51][1] = &other_arrays;
    double (*SumO)[51][1] = &other_arrays;
    double (*WeightHO)[51][1] = &other_arrays;
    double (*Output)[51][1] = &other_arrays;
    double (*DeltaWeightIH)[51][1] = &other_arrays;
    double (*DeltaWeightHO)[51][1] = &other_arrays;
    for (i = 0; i < 2; i++){
      for (j = 0; j < 51; j++){
        SumH[j][i] = (double *)malloc(sizeof(double));
        WeightIH[j][i] = (double *)malloc(sizeof(double));
        Hidden[j][i] = (double *)malloc(sizeof(double));
        SumO[j][i] = (double *)malloc(sizeof(double));
        WeightHO[j][i] = (double *)malloc(sizeof(double));
        Output[j][i] = (double *)malloc(sizeof(double));
        DeltaWeightIH[j][i] = (double *)malloc(sizeof(double));
        DeltaWeightHO[j][i] = (double *)malloc(sizeof(double));
      }
    }

When I compile I get: error: array type 'double [1]' is not assignable

I've tried some things I've found online such as SumH[j] = (double *)malloc(sizeof(double));

But then I get: error: array type 'double [51][1]' is not assignable

Or something like this yields the same error:

  for (j = 0; j < 51; j++){
    SumH[j] = (double *)malloc(sizeof(double));
    WeightIH[j] = (double *)malloc(sizeof(double));
    Hidden[j] = (double *)malloc(sizeof(double));
    SumO[j] = (double *)malloc(sizeof(double));
    WeightHO[j] = (double *)malloc(sizeof(double));
    Output[j] = (double *)malloc(sizeof(double));
    DeltaWeightIH[j] = (double *)malloc(sizeof(double));
    DeltaWeightHO[j] = (double *)malloc(sizeof(double));
  }

SOLUTION

I didn't cast malloc

    *SumH[j][i] = *(double *)malloc(sizeof(double));

Answer 1

If you want to allocate 2d arrays:

    /* allocate 2d arrays */
    double (*SumH)[51][1] = malloc(51*1*sizeof(double));
    double (*WeightIH)[51][1] = malloc(51*1*sizeof(double));
    double (*Hidden)[51][1] = malloc(51*1*sizeof(double));
    double (*SumO)[51][1] = malloc(51*1*sizeof(double));
    double (*WeightHO)[51][1] = malloc(51*1*sizeof(double));
    double (*Output)[51][1] = malloc(51*1*sizeof(double));
    double (*DeltaWeightIH)[51][1] = malloc(51*1*sizeof(double));
    double (*DeltaWeightHO)[51][1] = malloc(51*1*sizeof(double));
    /* ... */
    free(DeltaWeightHO);
    free(DeltaWeightIH);
    free(Output);
    free(WeightHO);
    free(SumO);
    free(Hidden);
    free(WeightIH);
    free(SumH);

Usage would be ... (*SumH)[j][i] ...

I doubt this is want you wanted. To allocate pointers to the first row of 2d arrays:

    /* allocate pointers to first row of 2d arrays */
    double (*SumH)[1] = malloc(51*1*sizeof(double));
    double (*WeightIH)[1] = malloc(51*1*sizeof(double));
    double (*Hidden)[1] = malloc(51*1*sizeof(double));
    double (*SumO)[1] = malloc(51*1*sizeof(double));
    double (*WeightHO)[1] = malloc(51*1*sizeof(double));
    double (*Output)[1] = malloc(51*1*sizeof(double));
    double (*DeltaWeightIH)[1] = malloc(51*1*sizeof(double));
    double (*DeltaWeightHO)[1] = malloc(51*1*sizeof(double));

Usage would be ... SumH[j][i] ...

To allocate array of pointers to rows

    /* allocate array of pointers to rows */
    double (*SumH[51])[1];
    for(i = 0; i < sizeof(SumH)/sizeof(SumH[0]); i++)
        SumH[i] = malloc(1*sizeof(double));

Usage would be ... SumH[j][i] ...

Answer 2

If you want pointers to arrays and want to initialize them, then you should be doing things much more simply:

double (*SumH)[5][2] = malloc(sizeof(*SumH));
double (*WeightIH)[5][2] = malloc(sizeof(*WeightIH));

Now you can use:

int k = 0;
for (int i = 0; i < 5; i++)
{
    for (int j = 0; j < 2; j++)
    {
        (*SumH)[i][j] = k;
        (*WeightIH)[i][j] = k++;
    }
}

Note that an array dimension of [1] is close to pointless.

FWIW, valgrind gives the following code a clean bill of health:

#include <stdio.h>
#include <stdlib.h>

int main(void)
{
    double (*SumH)[5][2] = malloc(sizeof(*SumH));
    double (*WeightIH)[5][2] = malloc(sizeof(*WeightIH));


    int k = 0;
    for (int i = 0; i < 5; i++)
    {
    for (int j = 0; j < 2; j++)
    {
        (*SumH)[i][j] = k;
        (*WeightIH)[i][j] = k++;
    }
    }

    for (int i = 0; i < 5; i++)
    {
    for (int j = 0; j < 2; j++)
        printf("[%f, %f]", (*SumH)[i][j], (*WeightIH)[i][j]);
    putchar('\n');
    }

    free(SumH);
    free(WeightIH);

    return 0;
}

The output is not very exciting:

[0.000000, 0.000000][1.000000, 1.000000]
[2.000000, 2.000000][3.000000, 3.000000]
[4.000000, 4.000000][5.000000, 5.000000]
[6.000000, 6.000000][7.000000, 7.000000]
[8.000000, 8.000000][9.000000, 9.000000]