Question

我在函数中填充了一个动态分配的float multi数组。

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

第二个函数不能访问正确的内存位置，因此它不起作用，但如果以静态方式定义multy数组，则会起作用。

有人知道为什么吗？

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指向动态数组的指针，指向动态数组的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个元素，因此这是不正确的。

它以静态方式工作，因为内存中的静态多维数组只是一维数组，为其提供了多索引（通过编译器）。这就是为什么在静态中你可能会解决有效的内存区域。

有关更多说明，请参见图片： enter image description here

Answer 2

如果你想要一个完全动态的矩阵（2d数组），你必须创建自己的元素访问函数：

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;

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

2 个答案: