将ANSI C / C89结构转换为int数组[]

Question

有没有一种有效的方法来将结构分配/转换为数组，反之亦然？

我拥有的结构如下：

struct A {
    int x, y;
}

struct B {
    struct A start;
    struct A end;
}

基本上，它们包含起点和终点位置的xy坐标。

我需要有效地分配它们，但是目前我只能这样做

/* sample code */
struct B b;
b.start.x = arr[i];
b.start.y = arr[i];
b.end.x = arr[i];
b.end.y = arr[i];


/* I can't do this in ANSI C / C89 as compound literals only allow constants */
b = (struct B) {(struct A) {arr[0], arr[1]}, (struct A) {arr[2], arr[3]}};

我也可以使用复合文字，但是当我使用标志-Wall -pedantic -ansi进行编译时，它在gcc中给了我警告

有没有一种方法可以将这四行分配减少到一条，而不会收到上述标志的警告。

问候

编辑：固定复合文字语法

Answer 1

struct A
{
    int x, y;
};

struct B
{
    struct A start;
    struct A end;
};

void InitA(struct A* s, int x, int y)
{
    s->x = x;
    s->y = y;
}

void InitB(struct B* s, int x1, int y1, int x2, int y2)
{
    InitA(&s->start, x1, y1);
    InitA(&s->end, x2, y2);
}

void InitBFromArray(struct B* s, int *a)
{
    InitB(s, a[0], a[1], a[2], a[3]);
}

int main()
{
    int a[] = { 1, 2, 3, 4 };
    struct B s;
    InitBFromArray(&s, a);
}

Answer 2

我想高效地做到这一点（在相同的编译器中，第一个代码和第二个代码的效率相同，就像您做的一样），只需编写：

int arr[N], i = 0;

b.start.x = arr[i++];
b.start.y = arr[i++];
b.end.x = arr[i++];
b.end.y = arr[i++];

这与您使用的两个示例都具有相同的效果。 同样，您可以执行此操作（但是大多数编译器应生成相同的代码：

int arr[N], *p = arr;

b.start.x = *p++;
b.start.y = *p++;
b.end.x = *p++;
b.end.y = *p++;

但是好的编译器必须生成与上述示例相同的代码。

为什么您认为第一种方法的效率会比第二种方法低？

通过复制内存块（甚至使用不同的指针重新解释数据）可以获得更高的效率，但这绝对是不可移植的代码

struct B *ptr = (struct B *)arr;  /* or arr + 4*i */
/* now use ptr->start.x, ptr->start.y, ptr->end.x and ptr->end.y */

请注意，最后一个示例可能是最高效的示例，因为您不必复制任何内容，但是肯定是不可移植的 ， 不正确的并且不建议使用编码。 （有时工作！）

Answer 3

假设您打算编写类似于以下内容的内容：

struct B b;
b.start.x = arr[i++];
b.start.y = arr[i++];
b.end.x = arr[i++];
b.end.y = arr[i++];

我将使用四行分配而不是复合文字，因为复合文字看起来太复杂而无法使用。 如果我需要多次执行这些分配并且循环不可行，那么我将编写一个辅助函数或宏。 例如：

function init_b (struct B *b, int *a)
{
  b->start.x = a[0];
  b->start.y = a[1];
  b->end.x = a[2];
  b->end.y = a[3];
}

init_b (&b, arr);

/* or */

#define INIT_B(b,a) do {\
  (b).start.x = (a)[0];\
  (b).start.y = (a)[1];\
  (b).end.x = (a)[2];\
  (b).end.y = (a)[3];\
} while (0)

INIT_B (b, arr);

如果启用了优化的编译器为上述所有代码生成几乎完全相同的代码，我不会感到惊讶。

do...while(0)构造可确保该宏在用作for循环或类似循环的单个语句主体时可以正常工作：

struct B *b;
/* ... */
int i;
for (i = 0; i < /*...*/; i++)
  INIT_B (b[i], arr + 4*i);