通过指针从动态分配的二维数组中获取值

Question

我在一个函数中填充了一个动态分配的浮点多数组。

第二个函数必须利用指向前一个函数中定义的数组第一个元素的指针来获取数组的值。

第二个函数没有访问正确的内存位置，所以它不起作用，但如果多数组是以静态方式定义的，它就会起作用。

有人知道为什么吗？

eval_cell 应该得到 div_int 中定义的值

float f_imp(float x, float y){
     return pow(x,2)+pow(y,2)-1;
}


int eval_cell(float* p){
    int s[4];
    s[0] = f_imp(*p, *(p+1)) <= 0;
    printf("%f %f\n",*p, *(p+1));

    s[1] = f_imp(*(p+3), *(p+4)) <= 0;
    printf("%f %f\n",*(p+3), *(p+4));

    s[2] = f_imp(*(p+9), *(p+10)) <= 0;
    printf("%f %f\n",*(p+9), *(p+10));

    s[3] = f_imp(*(p+6), *(p+7))  <= 0;
    printf("%f %f\n",*(p+6), *(p+7));

    printf("%d%d%d%d\n",s[0],s[1],s[2],s[3]);
    return s[0];
}

void div_int(float* x1, float* y1,float* x2,float* y2,
             float* f0, float* f2,float* f6,float* f8){
    int i,j,m;
    float* p;
    float** a_cell; // array 9x3 contente coordinate vertici e valore funzione
    *a_cell = (float**) malloc(9*sizeof(float*));
    for (i=0;i<9;i++){
       a_cell[i] = (float*) malloc(3*sizeof(float));
    }
    a_cell[0][0] = *x1;
    a_cell[0][1] = *y1;
    a_cell[0][2] = *f0;
    a_cell[2][0] = *x2;
    a_cell[2][1] = *y1;
    a_cell[2][2] = *f2;
    a_cell[6][0] = *x1;
    a_cell[6][1] = *y2;
    a_cell[6][2] = *f6;
    a_cell[8][0] = *x2;
    a_cell[8][1] = *y2;
    a_cell[8][2] = *f8;
/***   calcolo dei valori incogniti di a_cell            ***/
    a_cell[1][0] = (*x1+*x2)/2;
    a_cell[1][1] = *y1;
    a_cell[1][2] = f_imp(a_cell[1][0], a_cell[1][1]);
    a_cell[3][0] = *x1;
    a_cell[3][1] = (*y1+*y2)/2;
    a_cell[3][2] = f_imp(a_cell[3][0], a_cell[3][1]);;
    a_cell[4][0] = (*x2+*x1)/2;
    a_cell[4][1] = (*y2+*y1)/2;
    a_cell[4][2] = f_imp(a_cell[4][0], a_cell[4][1]);
    a_cell[5][0] = *x2;
    a_cell[5][1] = (*y2+*y1)/2;
    a_cell[5][2] = f_imp(a_cell[5][0], a_cell[5][1]);
    a_cell[7][0] = (*x1+*x2)/2;
    a_cell[7][1] = *y2;
    a_cell[7][2] = f_imp(a_cell[7][0], a_cell[7][1]);

    for (j=0;j<2;j++){
       m = j*3;
       for(i=0;i<2;i++){
       m += i;
       eval_cell(&a_cell[m][0]);
       }
    }
    p = *a_cell;
    for (i=0;i<9;i++){
        for (j=0;j<3;j++){
          printf("%f \n",*(p+3*i+j));
          printf("%f \n",a_cell[i][j]);
      printf("\n");
       }
    }
   free(a_cell);
   return;
}

Answer 1

这是因为您以错误的方式使用指针： 请参阅a_cell 是指向 9 个动态数组的指针，指向 3 个浮点数的动态数组。 因此，当您执行eval_cell(&a_cell[m][0])（或只是eval_cell(a_cell[m]) 这实际上是相同的）时，您实际上会获得指向3 个浮点数组的指针。然后你做：

int eval_cell(float* p){

...
s[2] = f_imp(*(p+9), *(p+10)) <= 0;

*(p+9) 将得到 3 个浮点数数组中的第 9 个元素，所以这是不正确的。

它以静态方式工作，因为 内存中的静态多维数组只是一维数组，您被赋予了多索引（由编译器）。这就是为什么在静态中您可能会处理有效的内存区域。

更多解释见图片：

Answer 2

如果你想要一个完全动态的矩阵（二维数组），你必须制作自己的元素访问函数：

double *
make_array (unsigned int rows, unsigned int cols)
{
  return malloc (rows * cols * sizeof (double));
}

double *
array_element (double *a, unsigned int cols, unsigned int i, unsigned int j)
{
  return a + i * cols + j;
}

#define A(i,j) (*array_element ((a), (cols), (i), (j)))

double *a;
unsigned int rows, cols;

a = make_array (rows, cols);
A(3,4) = 3.14;
printf ("%f\n:" A(3,4));

编辑：

在你的程序中

*a_cell = (float**) malloc(9*sizeof(float*));

应该是

a_cell = (float**) malloc(9*sizeof(float*));

对于

p = *a_cell;