多个结构，需要在一个方法中访问的相同字段

Question

我目前尝试用 C 编写一些有趣的小游戏。

为此，我需要能够在……好吧……C中打印类似窗口的结构。

我想使用通用渲染方法（我们称之为frame_render(...)）来渲染所有不同的“ui 元素”

现在的问题是：如何解决？

给定场景：

// Theoretical base
struct frame { int x; int y; int width; int height; }
struct button { int x; int y; int width; int height; ... }
struct whatever { int x; int y; int width; int height; ... }

我如何确保我的 x、y、width 和 height 始终处于正确的记忆点？ 一开始就“只是”将它们按相同的顺序排列就足够了吗？

另外，如何设计方法头来接受它？

Answer 1

如果所有结构都以相同类型的成员开头，以相同的顺序，对应的成员将具有相同的偏移量。大多数编译器都可以配置为允许使用任何结构类型的指针来检查任何其他的公共初始序列的成员，但有一些问题：

1. 在一些不常见的平台上，如果一个对象后跟填充字节，则将对象和填充字节一起写入的指令（可能在后者中存储无意义的值）可能比只写入对象的指令快。如果一个成员在某些结构中后跟一个填充字节，但在另一个结构中是有意义的数据，则使用其后跟填充字节的类型对该成员的写入可能会用无意义的值覆盖“填充字节”，从而破坏值其他结构类型中的以下成员。我不知道当前使用的任何体系结构对于位域以外的任何结构成员来说都是一个问题，而且我不知道任何当前的实现即使对那些来说也是一个问题，但是在某些平台上可能会出现这种可能性，尤其是位域。

2. 鉴于类似：

   int readField1OfS1(struct s1 *p) { return p->field1; }
   
   struct s2 *myStruct2Ptr;
   
   if (readField1ofS1((struct s1*)myStruct2Ptr)
      ...
   

   像 gcc 和 clang 这样的一些编译器不能可靠地允许从函数返回的值可能依赖于 struct s2 类型的对象的公共初始序列的一部分所持有的值。调用，除非优化被禁用（例如使用-fno-strict-aliasing 选项）。我认为在函数调用表达式中存在从struct s2* 到struct s1* 的转换应该允许质量编译器识别任何函数可能对struct s1 类型的对象执行某些操作可能在struct s2 上完成，但由于标准没有明确要求，gcc 和 clang 的作者拒绝做出任何努力来可靠地识别此类构造，即使在上述简单的情况下也是如此。

使用通用初始序列规则的代码几乎可以在任何经过​​适当配置的编译器上可靠地运行，但是像 gcc 和 clang 这样的代码必须使用 -fno-strict-aliasing 选项进行特殊配置。自 1974 年以来，利用通用初始序列保证的能力一直是该语言的成熟部分，并且在编写该标准时，任何熟悉该语言的人都会理解它旨在允许像上面那样的构造，编译器应该不难识别。然而，由于标准的作者没有明确要求以有用的方式兑现 CIS 保证，clang 和 gcc 的作者决定他们宁愿声称依赖于数十年历史的 CIS 保证的程序是“损坏的”，而不是向 40 多年的先例致敬。

Answer 2

一开始就“只是”将它们按相同的顺序排列就足够了吗？

是的，如果你像上面所做的那样小心的话。

另外，如何设计方法头来接受它？

有不同的方法可以做到这一点。

下面是一个示例，使用 [ugly] 等效的 c++“基”类：

enum type {
    FRAME,
    BUTTON,
    WHATEVER
};

struct geo {
    int x;
    int y;
    int width;
    int height;
    enum type type;
};

struct frame {
    struct geo geo;
};

struct button {
    struct geo geo;
    int updown;
};

struct whatever {
    struct geo geo;
    int what;
    int ever;
};

void
frame_render(struct geo *geo)
{
    struct frame *frm;
    struct button *but;
    struct whatever *what;

    switch (geo->type) {
    case FRAME:
        frm = (struct frame *) geo;
        frame_render_frame(frm);
        break;

    case BUTTON:
        but = (struct button *) geo;
        printf("x=%d y=%d updown=%d\n",geo->x,geo->y,but->updown);
        frame_render_button(but);
        break;

    case WHATEVER:
        what = (struct whatever *) geo;
        printf("x=%d y=%d what=%d ever=%d\n",
            what->geo.x,what->geo.y,what->what,what->ever);
        frame_render_whatever(what);
        break;
    }
}

下面是一个使用虚函数表的方法：

enum type {
    FRAME,
    BUTTON,
    WHATEVER
};

struct geo;

// virtual function table
struct virtfnc {
    void (*calc)(struct geo *);
    void (*render)(struct geo *);
};

struct geo {
    int x;
    int y;
    int width;
    int height;
    enum type type;
    struct virtfnc *fnc;
};

struct frame {
    struct geo geo;
};

struct button {
    struct geo geo;
    int updown;
};

struct whatever {
    struct geo geo;
    int what;
    int ever;
};

void
frame_render(struct geo *geo)
{
    struct frame *frm = (struct frame *) geo;

    // whatever
}

void
button_render(struct geo *geo)
{
    struct button *but = (struct button *) geo;

    // whatever
}

void
whatever_render(struct geo *geo)
{
    struct whatever *what = (struct whatever *) geo;

    // whatever
}

void
any_render(struct geo *geo)
{

    geo->fnc->render(geo);
}

这是使用union 的第三种方式。它更简单，但要求基础结构与最大的子类一样大：

enum type {
    FRAME,
    BUTTON,
    WHATEVER
};

struct frame {
    ...
};

struct button {
    int updown;
};

struct whatever {
    int what;
    int ever;
};

struct geo {
    int x;
    int y;
    int width;
    int height;
    enum type type;
    union {
        struct frame frame;
        struct button button;
        struct whatever what;
    } data;
};

void
any_render(struct geo *geo)
{

    switch (geo->type) {
    case FRAME:
        render_frame(&geo->data.frame);
        break;

    case BUTTON:
        render_button(&geo->data.button);
        break;

    case WHATEVER:
        render_whatever(&geo->data.what);
        break;
    }
}

---

更新：

这种方法铸造安全吗？例如。将所有内容放入frame* 类型的数组中，然后访问frame->geo？或者这会导致以后调用free(..) 时出现任何问题？

如果分配是使用派生类型（例如frame、button）完成的，free 没有问题，但不是基本类型geo ：malloc(sizeof(struct button)).

要拥有一个简单 [形状] 数组，需要使用union 方法（即所有派生结构必须具有相同的大小）。但是，如果我们有一些子类型比其他子类型使用 很多 更多空间，这将是浪费：

struct polyline {
    int num_points;
    int x[100];
    int y[100];
};

这可以仍然用方法#1或#2[子类型结构的大小不同]用一个间接指针数组来完成：

void
all_render(struct geo **glist,int ngeo)
{

    for (;  ngeo > 0;  --ngeo, ++glist)
        any_render(*glist);
}

我会考虑使用 [双重] 链表，而不是一组不同形状的数组。这允许子类型结构具有不同的大小。我们将向struct geo 添加一个struct geo *next 元素。然后，我们可以这样做：

void
all_render(struct geo *geo)
{

    for (;  geo != NULL;  geo = geo->next)
        any_render(geo);
}

列表方法可能更可取，特别是如果我们动态添加/删除形状[或根据 Z 深度重新排序它们]。

或者，某些形状可能包含其他形状。所以，我们可以将struct geo *children 添加到struct geo。然后，很容易（例如）绘制一个包含框，然后通过遍历children 列表来绘制该框内的所有形状。如果我们选择children，我们也可以添加struct parent *parent，这样每个形状都知道它包含什么形状。

Answer 3

“经典”方法是拥有一个包含所有可能对象的union 的struct 和一个标识已传递的确切对象的enum：

struct renderable {
    enum {FRAME, BUTTON, WHATVERE, ...} type;
    union {
        struct frame frame;
        struct button button;
        struct whatever whatever;
        ....
    } data;
};

将此结构传递给渲染器后，在type 字段上使用switch 来提取坐标等：

void renderer (renderable *obj, ...) {
    ...
    switch(obj->type) {
        case FRAME: x = obj->data.frame.x; ...; break;
        case BUTTON: x = obj->data.button.x; ...; break;
        ...
    }
    ...
}

据说正是这种怪物鼓励了 Stroustrup 发明了 C++ :)

已编辑

另一个“经典”解决方案是有一个单独的struct，它具有任何对象的尺寸和位置：

struct geometry {
    int x, y, width, height;
}

您可以将此结构存储在任何特定于对象的struct 的开头并使用强制转换来访问它：

struct frame {
    struct geometry geo;
    // more stuff
};

struct frame frame = {....};
rendered((void*)&frame, ...);

在渲染器中：

void renderer (void *obj, ...) {
    ...
    struct geometry *geo = (struct geometry *)obj;
    geo->x ...
}

后一种方法可能有些不安全。为了使其 100% 安全，请将几何体与特定于对象的信息分开，并将它们作为两个单独的结构传递给渲染器。