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

大家好，我有一个无法解决的问题，可能是一些琐碎的事情

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

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

（x=1；x<9；x++）的

{
对于（u=0；u<2；u++）{
对于（z=0；z<4；z++）{
数组[x]=arrayPayload[u]。字节[z]；
}
}
}

---

如果你能帮助我，请提前感谢

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

array[u*有效负载大小/字节数+z+1]

或者，总体上更简单的方法是使用一个循环，从0到有效负载大小进行计数，然后从该计数器计算剩余的：

array[i+1]=arrayPayload[i/字节\编号]。bytes[i%字节\编号]

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

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

x=1；
对于（u=0；u<2；u++）{
对于（z=0；z<4；z++）{
数组[x++]=arrayPayload[u]。字节[z]；
}
}

正确的解决方案利用了（而不是“让它变得愚蠢复杂”）。始终保持循环尽可能简单。从零迭代到已知值。当不需要时，不要使用多个迭代器

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\u t i=0；i您的“问题”是
x
在外部循环中递增，因此您得到：

x u z
-----
1 0 0
1 0 1
1 0 2
1 0 3
1 1 0
1 1 1
1 1 2
1 1 3
1 0 0
2 0 1
2 0 2
2 0 3
2 1 0
2 1 1
2 1 2
2 1 3
...
8 0 0
8 0 1
8 0 2
8 0 3
8 1 0
8 1 1
8 1 2
8 1 3

因此，
array
的所有元素最终都等于
arrayPayload[1]。字节[3]

只需放下外循环，并在每次赋值后递增
x

如果所有变量
array
，
arrayPayload
，
bytes
都是数组（即没有一个是指针），则应执行以下操作：

#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;
    }
}

这里有一个可能的解决方案

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

for（int i=1；i<9；i++）{
数组[i]=arrayPayload[（i-1）/4]。字节[（i-1）-（（i-1）/4）*4]；
}
您想做什么？在您的问题中，您正在使用索引
1
到
8
索引到
array
。这是有意的吗？还是您的意思是
0
到
7
？@mingo都是变量数组？还是其中一些是指针？@mingo关于您的编辑，[closed]状态是指那些不清楚的问题，需要通过海报进行改进。当其他用户投了3张接近票时，有些问题会以这样的方式结束。这里不是这样，你的问题是可以的。如果你认为问题已经解决，并且你已经接受了答案，那么你可以就此放弃。当只有1个i时，使用3个迭代器也没有意义需要。@Lundin更好的可读性，我认为这样可以更清楚地显示原始代码出错的地方，但为什么要添加所有不必要的复杂性？如果编译器未能优化除法，这只会使代码更难阅读，可能会慢得多。@Lundin我的前提是，这可能会进一步，然后只会增加到索引9然后，就额外的工作而言，这种扩展非常好，而您的解决方案需要为每个集合添加更多的循环（或另一个循环来迭代集合）对于给定的长度，我认为你的解决方案是更好的。特别是避免魔术数字是很好的建议。没有足够的信息来对数据的性质做出任何假设。@ Lundin，你认为第二版本是一种改进吗？是的，我说我有这个前提，不确定这是必要的。e这里绝对没有必要涉及除法。嗯……所以当
arrayPayload
从2个元素变为4个元素的那天，你会做4个循环吗？@4386427如果我有任何形式的数据性质的信息，我会相应地编写代码。如果我没有，我会尽可能简单易读地编写代码。代码重复是非常重要的不，如果只是这两个小数据集，那么如果它们太多的话就不那么重要了。好吧，你说得对，我不会。但我自己永远不会这样做。嵌套循环的“开销”和/或复杂性（IMO）非常低。写“易于维护”的好处代码要大得多。@4386427通常数组访问从索引0开始，然后使用多个循环是有意义的。但是由于这段代码使用了奇怪的、非平凡的索引，所以我没有这样写。在这种情况下，这是一种自文档化的代码。让读者思考“他为什么要写两个循环”是有意义的。通常经过深思熟虑，我的首选是获取
sizeof arrayPayload.bytes/sizeof arrayPayload[0]。bytes[0]
从循环中移出常量。我发现这更容易阅读。而且可能更快，这取决于编译器是存储结束条件还是每次都计算它。@KamiKaze好吧，将大小计算移出循环条件是可以的。但是，请记住，C中的
常量int
不能像我一样是编译时常量但是C++编译器一旦应用了优化，就没什么关系了……不需要，但是每次迭代都可以计算比较，这比第一次保存时要慢。我不知道哪个编译器会用任何优化来编译它。我希望我必须使用的那个古器不能优化。它。@KamiKaze否，将在编译时处理
sizeof
事物（VLA除外）-否worries@KamiKaze任何一个理智的编译器都会处理这个除法，这看起来很复杂
x u z
-----
1 0 0
1 0 1
1 0 2
1 0 3
1 1 0
1 1 1
1 1 2
1 1 3
1 0 0
2 0 1
2 0 2
2 0 3
2 1 0
2 1 1
2 1 2
2 1 3
...
8 0 0
8 0 1
8 0 2
8 0 3
8 1 0
8 1 1
8 1 2
8 1 3

#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;
    }
}

#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);
}

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