программа загружается при назначении динамически распределяемого 3D-массива

#c #multidimensional-array #segmentation-fault

#c #многомерный массив #ошибка сегментации

Вопрос:

Я написал несколько кодов о динамическом распределении 3D-массивов в codeblocks с помощью компилятора GCC.

Версия1:

 void*** alloc3(int n_s, int n_row, int n_col, int size)
{
 void*** p=(void***)malloc(n_s*sizeof(void**));
 int i,j,k;
 if (p==NULL) return NULL;
 for(i=0;i<n_s;i  ){
 p[i] = (void**)malloc(n_row*sizeof(void*));
 for(j=0;j<n_row;j  )
   {
    p[i][j]=(char*)malloc(n_col*size);
    if(p[i][j]==NULL) {free(p[0]);free(p);return NULL; }
   }
  }
 return p;
}

Версия2:

 void*** alloc3 (int n1, int n2, int n3, int size)
{
int i3,i2;
void ***p;

if ((p=(void***)malloc(n3*sizeof(void**)))==NULL)
        return NULL;
if ((p[0]=(void**)malloc(n3*n2*sizeof(void*)))==NULL) {
        free(p);
        return NULL;
  }
if ((p[0][0]=(void*)malloc(n3*n2*n1*size))==NULL) {
        free(p[0]);
        free(p);
        return NULL;
  }

for (i3=0; i3<n3; i3  ) {
        p[i3] = p[0] n2*i3;
        for (i2=0; i2<n2; i2  )
                p[i3][i2] = (char*)p[0][0] size*n1*(i2 n2*i3);
  }
return p;
}

Я протестировал эти коды.

 double*** B= (double*** )alloc3(n_row,n_col,n_s,sizeof(double));
for(int i=0;i<n_s;i  )
{
  for(int j=0;j<n_row;j  )
  {
    for(int k=0;k<n_col;k  )
    {
        printf("(%d,%d,%d)t",i,j,k);
        B[i][j][k] = 1.0;
    }printf("n");
}printf("----------n");
}

Возникли подсказки / ошибка отладки:

но если я отключу строку B[i][j][k] = 1.0; , все будет в порядке. Я не могу понять, что не так с этим материалом. Любая помощь будет оценена.

1. Это явно C, а не C . Кроме того, free(p[0]); free(p); произойдет утечка памяти.

2. Не воспроизводится

3. версия 2 является фиктивной, вы никогда не выделяете p[1] и т. Д.

4. версия 1 должна работать, если нет сбоев выделения (код проверки ошибок и восстановления очень плохой)

5. Вы нашли мой ответ полезным?

Ответ №1:

Вы не говорите, какой из них не удался, но на самом деле это не имеет значения, поскольку оба неверны.

В C вы не можете преобразовать тип void ** или тип void *** в тип double ** или тип double ***, не вызывая неопределенного поведения. Обе функции в вашем примере делают это.

Было бы очень неудобно и, вероятно, на самом деле невозможно правильно написать универсальную функцию, которая выделяет память, как вы себе представляете.

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

 double (*d)[y][x] = malloc( z * y * x * sizeof( double ) );
d[z-1][y-1][x-1] = 123.45;

Вам нужно позвонить бесплатно только один раз:

 free( d );