我如何用 C 中的循环解决这个问题？

Question

大家好，我有个问题解决不了，可能是小事！

我需要用循环自动执行这段代码：

                array[1]=arrayPayload[0].bytes[0];
                array[2]=arrayPayload[0].bytes[1];
                array[3]=arrayPayload[0].bytes[2];
                array[4]=arrayPayload[0].bytes[3];
                array[5]=arrayPayload[1].bytes[0];
                array[6]=arrayPayload[1].bytes[1];
                array[7]=arrayPayload[1].bytes[2];
                array[8]=arrayPayload[1].bytes[3];

我试过这个解决方案，但显然它不起作用，因为索引没有正确滚动！

    for(x=1 ; x < 9 ; x++){
        for(u=0 ; u < 2 ; u++){
            for(z=0 ; z < 4 ; z++){
                array[x] = arrayPayload[u].bytes[z];
            }
        }
    }

如果你能帮助我，在此先感谢！！

Answer 1

移除最外层的循环并改为从两个内部计数器计算数组索引：

array[u * PAYLOAD_SIZE/BYTE_NUMBER + z + 1]

或者，总体上更简单的方法是让一个循环并从 0 计数到 PAYLOAD_SIZE 排除，然后从该计数器计算其余部分：

array[i + 1] = arrayPayload[i / BYTE_NUMBER].bytes[i % BYTE_NUMBER]

Answer 2

int x,y,z;
for(x=1 ; x < 9 ; x++){
  y= (x-1) / 4;
  z= (x-1) % 4;
  array[x] = arrayPayload[y].bytes[z];  
}

这有点棘手，因为指标排列不当（x 领先一步）。但是你可以很容易地用除法和模数 4 来做到这一点。

当你通过一个数组 array 时，你只需要一个循环，其余的取决于数组中的位置，所以你应该使用 x 作为其余部分的参考。

也许更容易阅读，编译器将其更改为：

int x;
for(x=0 ; x < 8 ; x++){
  const int y= x / 4;
  const int z= x % 4;
  array[x+1] = arrayPayload[y].bytes[z];  
}

Answer 3

每次赋值后都需要 x+1，因此将 x 增量放在最外层循环没有意义。

    x=1;
    for(u=0 ; u < 2 ; u++){
        for(z=0 ; z < 4 ; z++){
            array[x++] = arrayPayload[u].bytes[z];
        }
    }

Answer 4

正确的解决方案使用 KISS principle（而不是“让它愚蠢地复杂化”）。始终使循环尽可能简单。从零迭代到已知值。不要在不需要时使用多个迭代器。

for(size_t i=0; i<4; i++)
{
  array[i+1] = arrayPayload[0].bytes[i];
}
for(size_t i=0; i<4; i++)
{
  array[i+5] = arrayPayload[1].bytes[i];
}

如果可能，将“幻数”换成有意义的命名常量。我不知道这些数据是什么，但生产质量代码看起来类似于：

for(size_t i=0; i<SET_SIZE; i++)
{
  array[i+OFFSET0] = arrayPayload[SET0].bytes[i];
}
for(size_t i=0; i<SET_SIZE; i++)
{
  array[i+OFFSET1] = arrayPayload[SET1].bytes[i];
}

Answer 5

你的“问题”是 x 在外循环中递增，所以你得到：

所以 array 的所有元素最终都等于 arrayPayload[1].bytes[3]。

只需删除外层循环并在每次赋值后递增 x。

如果所有变量 array、arrayPayload、bytes 都是数组（即其中 none 是指针）你应该这样做：

#define ARRAY_OFFSET 1
#define ELM_ARRAY (sizeof array / sizeof array[0])
#define ELM_PAYLOAD (sizeof arrayPayload / sizeof arrayPayload[0])
#define ELM_BYTES (sizeof arrayPayload.bytes / sizeof arrayPayload[0].bytes[0])


// Optional assert to make sure 'array' size is ok
assert(ELM_ARRAY >= (ELM_PAYLOAD * ELM_BYTES + ARRAY_OFFSET);

x = ARRAY_OFFSET;
for (size_t i = 0; i < ELM_PAYLOAD; ++i)
{
    for (size_t j = 0; j < ELM_BYTES; ++j)
    {
        array[x] = arrayPayload[i].bytes[j];
        ++x;
    }
}

根据实际数组大小计算循环条件将使您的代码更易于维护，以防其中一个数组更改大小。

如果 array、arrayPayload、bytes 中的一个或多个是指针，您应该给出元素的数量 - 从而给出循环条件 - 使用定义，例如#define ELM_PAYLOAD 2

使用 memcpy 的替代方法：

#define ARRAY_OFFSET 1
#define ELM_ARRAY (sizeof array / sizeof array[0])
#define ELM_PAYLOAD (sizeof arrayPayload / sizeof arrayPayload[0])
#define SZ_BYTES_ELEMENT (sizeof arrayPayload[0].bytes[0])
#define ELM_BYTES (sizeof arrayPayload.bytes / SZ_BYTES_ELEMENT)

// Optional assert to make sure 'array' size is ok
assert(ELM_ARRAY >= (ELM_PAYLOAD * ELM_BYTES + ARRAY_OFFSET);

for (size_t i = 0; i < ELM_PAYLOAD; ++i)
{
    memcpy(array + i * ELM_BYTES + ARRAY_OFFSET, 
           arrayPayload[0].bytes, 
           ELM_BYTES * SZ_BYTES_ELEMENT);
}

Answer 6

这是一个可能的解决方案

 for(int i = 1 ; i < 9; i++) {
        array[i] = arrayPayload[(i-1)/4].byte[(i-1) -(((i-1)/4) * 4)];
    }

我如何用 C 中的循环解决这个问题？

How can I solve this problem with loops in C?

c

arrays

logic

loops

while-loop