c - 在循环中填充数组

Question

我有一个不断被调用的函数。我有 3 个较小的数组，每个循环都需要将它们打包成一个较大的数组

float* a;
float* b;
float* c;
float* abc;

a = calloc(1, sizeof(float)*3);
b = calloc(1, sizeof(float)*3);
c = calloc(1, sizeof(float)*3);
abc = calloc(1, sizeof(float)*9);


void update() {

   for(int i = 0; i < 3; i++) {
     fill_a(a);
     fill_b(b)
     fill_c(c);

     abc[0] = a[0];
     abc[1] = b[0];
     abc[2] = c[0];

     abc[0] = a[1];
     abc[1] = b[1];
     abc[2] = c[1];

     abc[0] = a[2];
     abc[1] = b[2];
     abc[2] = c[2];
   }
}

free(a);
free(b);
free(c);
free(abc);

上面的实现存在问题，因为值在后续循环中被覆盖。

我尝试为值添加偏移量，如下所示:

   for(int i = 0; i < 3; i++) {
     fill_a(a);
     fill_b(b)
     fill_c(c);

     abc[(i*9)+0] = a[0];
     abc[(i*9)+1] = b[0];
     abc[(i*9)+2] = c[0];

虽然这似乎有效，但如果我尝试一一添加也行不通。

我还尝试通过索引值添加偏移量，但它会计数到无穷大。

int idx = 0;

void update() {

   for(int i = 0; i < 3; i++) {
     fill_a(a);
     fill_b(b)
     fill_c(c);

     abc[++idx] = a[0];
     abc[++idx] = b[0];
     abc[++idx] = c[0];

     abc[++idx] = a[1];
     abc[++idx] = b[1];
     abc[++idx] = c[1];

我还尝试在一个 for 循环中填充第一个数组。然后在更新循环中将这些值放入更大的数组中。

int idx;

idx = 0;
void update() {

   for(int i = 0; i < 3; i++) {
     fill_a(a);
     fill_b(b)
     fill_c(c);
   }
  int tidx = idx;
  abc[++tidx] a[0];
  abc[++tidx] b[0];
  abc[++tidx] c[0];
  ....
  idx = tidx;
 }

但 idx 再次趋于无穷大。如何安排这个算法，以便我可以用较小数组中的值填充该循环内的较大数组，同时保持偏移量有序？

较大数组的值总是会在循环中被覆盖，因此在填充后，它会在其他地方使用，然后覆盖下一次更新调用。

编辑我尝试过 gdb 调试，一次单步执行一个变量。

预期的输出是这样的:

a = { 0, 1, 2 };
b = { -3, -2, -1 };

abc = { 0, -3, 11.
        1, -2, 22 };

这是来自实际代码的完整工作示例。

    int count = 3;
    float* v_buff;
    float* c_buff;

    size_t vs = sizeof(float) * 6);
    v_buff = calloc(1, (vs));


void update() {
     for(int i = 0; i < count; i++) {
         float a[3] = { 0, 1, 2}; //these will be new every update
         float b[3] = { -3, -2, -1};
         int idx = 0;
         v_buff[++idx] = a[0];
         v_buff[++idx] = a[1];
         v_buff[++idx] = a[2];

         v_buff[++idx] = b[0];
         v_buff[++idx] = b[1];
         v_buff[++idx] = b[2];
     }
}

该示例代码可以编译，但同样的情况也适用。尝试偏移:

v_buff[(i * 3) + (++idx)] = a[0];

导致我的计数器运行到无穷大或者只是覆盖 v_buff 中的第一组值。

Answer 1

对于您的 abc 数组，第一种方法不起作用，因为您将数组的前 3 个条目设置为 a 的内容，然后用b 的内容，然后再次使用 c 的内容。

您的第二种方法很接近，但不完全是因为您将 i 乘以 9 而不是 3，因此索引在第一次迭代后超出范围。

您的第三种方法也很接近，但问题是您使用的是前增量(++idx)而不是后增量(idx++)，因此您的索引从 1 到 9 而不是 0 到 8。

此外，您的 update 函数正在循环调用 fill_a、fill_b 和 fill_c。如果没有看到这些函数，我猜测它每次都会用相同的内容填充它们，因此这些函数可能不需要循环。

因此，假设 4 个数组中每个数组的分配和释放都发生在 update 之外，则该函数应如下所示:

void update()
{
    int i;

    fill_a(a);
    fill_b(b)
    fill_c(c);

    for(int i = 0; i < 3; i++) {
        abc[(i*3)+0] = a[i];
        abc[(i*3)+1] = b[i];
        abc[(i*3)+2] = c[i];
    }
}

在循环的第一次迭代中，i 为 0，因此这三行的计算结果为:

abc[0] = a[0];
abc[1] = b[0];
abc[2] = c[0];

在第二次迭代中，i 为 1，主体计算结果为:

abc[3] = a[1];
abc[4] = b[1];
abc[5] = c[1];

在第三次迭代中，i 为 2，主体计算结果为:

abc[6] = a[2];
abc[7] = b[2];
abc[8] = c[2];

你也可以这样实现:

void update()
{
    int i, idx;

    fill_a(a);
    fill_b(b)
    fill_c(c);

    for(int i = 0, idx = 0; i < 3; i++) {
        abc[idx++] = a[i];
        abc[idx++] = b[i];
        abc[idx++] = c[i];
    }
}