c - 管理内存方向数组

Question

我的结构中有几个变量。

struct my_struct{
    float variable_2_x[2],variable_2_y[2],variable_2_z[2];
    float coef_2_xyz[3];    

    float variable_3_x[3],variable_3_y[3],variable_3_z[3];
    float coef_3_xyz[3];

    float variable_4_x[4],variable_4_y[4],variable_4_z[4];
    float coef_4_xyz[3];
};

该结构将包含拉格朗日多项式 (en.wikipedia.org/wiki/Lagrange_polynomial) 系数，对于多个多项式长度:2、3、4。该系数的值很容易计算，但问题是，我必须重复相同的代码来创建每个多项式。例如

// T_space is a cube with {[-1:1][-1:1][-1:1]} dimension, 
// its call transformed space.
// distance is the distance between two points of T_space
// point_1 its the point where the function has value 1
p = 2; 
step = distance / p;

polinoms.coef_2_xyz[0] = 1.0:
polinoms.coef_2_xyz[1] = 1.0:
polinoms.coef_2_xyz[2] = 1.0:
for( i = 0; i < p ; ++i) 
{
    polinoms.pol_2_x[i] = (T_space.xi[point_1] + step) + (i * step);
    polinoms.pol_2_y[i] = (T_space.eta[point_1] + step) + (i * step);
    polinoms.pol_2_z[i] = (T_space.sigma[point_1] + step) + (i * step);


    polinoms.coef_2_xyz[0]*= (T_space.eta[point_1] - polinoms.pol_2_x[i]);
    polinoms.coef_2_xyz[1]*= (T_space.eta[point_1] - polinoms.pol_2_y[i]);
    polinoms.coef_2_xyz[2]*= (T_space.eta[point_1] - polinoms.pol_2_z[i]);

}

因为我不想在代码中多次重复相同的循环。更重要的是，代码中的下一步我需要将多项式梯度的乘积积分到立方体中的每个点。

能够独立调用结构体的每个数组将非常有用。 据我所知，变量不能在运行时动态调用。我想创建一个包含结构体的内存方向的数组。像这样的东西。

// declare variable to store memory directions
float mem_array[12];

// some code

mem_array[0] = &variable_2_x;
mem_array[1] = &variable_2_y;
mem_array[2] = &variable_2_z;
mem_array[3] = &coef_2_xyz;
mem_array[4] = &variable_3_x;

mem_array[11] = &variable_4_z;
mem_array[12] = &coef_4_xyz;

// work calling mem_array.

但我不知道这是否可能或是否有效。如果您认为这不是解决问题的正确方法，我愿意接受建议。因为我真的被这个问题困扰了。

我已将问题编辑得更清楚，希望对您有所帮助。

Answer 1

你最好动态分配你需要的内存。您可以拥有一个表示单个拉格朗日多项式(任何阶数)的结构，然后拥有一个由这些多项式组成的数组，每个阶数一个。

如果您愿意，您还可以将多项式的阶数存储为结构体的成员。您应该能够将处理这些问题的代码分解为采用拉格朗日多项式*的函数，确定顺序，并执行所需的任何计算。

所有这一切的主要好处是，您不需要为每个订单都有特殊的代码，您可以对任何大小的多项式使用相同的代码(和相同的结构)。

示例如下:

struct LagrangePolynomial {
    float *x;
    float *y;
    float *z;
};

对于 p=2:

LagrangePolynomial p;
p.x = malloc(sizeof(float)*2);
p.y = malloc(sizeof(float)*2);
p.z = malloc(sizeof(float)*2);
for (size_t i=0; i<2; i++) {
    p.x[i] = ...;
    p.y[i] = ...;
    p.z[i] = ...;
}

完成结构后，您可以释放已分配的所有内存。

free(p.x);
free(p.y);
free(p.z);

如前所述，您可以拥有一个数组。

LagrangePolynomial ps[4];
for (size_t i=0; i<4; i++) {
    p[i].x = malloc(sizeof(float)*2);
    p[i].y = malloc(sizeof(float)*2);
    p[i].z = malloc(sizeof(float)*2);
    for (size_t j=0; j<2; j++) {
        p[i].x[j] = ...;
        p[i].y[j] = ...;
        p[i].z[j] = ...;
    }
}