Question

我在 struct 中有几个变量。

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]);

}

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

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

// 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

你最好动态分配你需要的内存。你可以有一个表示单个拉格朗日多项式（任何顺序）的结构，然后有一个这样的数组，每个顺序一个。

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

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

以下示例：

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] = ...;
    }
}

管理内存方向的数组

1 个答案: