在C中，只有类型化的联合才能解决这种类型的数组数据声明吗？

我试图提出一种方法来声明几个 是结构的数组，其中每个后续数组使用先前数组的一部分。 减少重复的方式。这样每个元素只声明一次

从概念上来说，想象这四个数组，其中一个给定的元素编号 出现在两个数组中意味着表示实际相同的内容，而不仅仅是 另一个值相同的

some_type group_A[] = {
    elt0, elt1, elt2, elt3, NULL
};

some_type group_B[] = {
    elt0, elt1, elt2, elt3,  // those are all A's
    elt4, elt5, NULL         // these are new to B
};

some_type group_C[] = {
    elt0, elt1, elt2, elt3,  // those are all A's
    elt6, elt7, elt8, NULL   // these are new to C
};

some_type group_D[] = {
    elt0, elt1, elt2, elt3, elt4, elt5, // those are all B's
    elt9, elt10, elt11, NULL            // these are new to D
};

您可以假设

some_type

已经是某种结构的typedef

我想做的是消除多余的声明，因为它们总体上看起来不整洁，并且因为它们让您可以更新不一致性。这里是更紧凑的表示法，其中组中的条目可以是普通元素，也可以是对此类元素的另一个数组的引用

（您可以通过结尾处的NULL ponter推断每个数组声明中的每个元素实际上都是指向相同类型结构的指针。）

换句话说，我想要一种方法来声明组B和组C都以组a中的所有内容开始，但之后都有它们的元素，组D包含组B中的所有内容（本身也包括组a中的所有内容），然后添加自己的元素

我希望这是声明性的，只是一组数组数据声明，发生在编译时，而不是运行时一组数据结构构建代码

这将被禁止递归，至少在实践中和运行时是如此

是否有一个很好的、声明式的、看起来像数组的实现，或者我必须恢复到一些更复杂的动态数据结构实现，这些实现在编译时不是我喜欢的方式固定的

我的直觉是，某种带有标签的联盟可能是唯一的出路

struct pointer_or_doublepointer {
    int  which_kind;   // 0 == .element is valid; 1 == .table is valid
    union {
        real_type *  element; // valid only when which_kind == 0
        real_type ** table;   // valid only when which_kind == 1
    };
}

然后我会为指针或双指针创建一个typedef

这真的是最好的方式来设置这样的东西，还是有一些 想到其他更好更直接的解决方案了吗？请再次记住，这一切都应该通过数据声明来完成，而不是通过代码

---

这是纯C，而不是C++或其他变体。

因为既然你说其他数组的引用只会出现在开始，一个简单的表示方法就是把这个引用与其余元素分开：

struct ElementList {
    struct ElementList *prefix; //Reference to elements of another array, or NULL
    some_type *elements;        //additional elements
};

---

这比

union

解决方案更为有限，但可能更易于使用。

您希望这项工作吗

#define GROUPA elt0, elt1, elt2, elt3
#define GROUPB GROUPA, elt4, elt5
#define GROUPC GROUPA, elt6, elt7, elt8
#define GROUPD GROUPB, elt9, elt10, elt11

some_type group_A[] = {
    GROUPA, NULL
};

some_type group_B[] = {
    GROUPB, NULL
};

some_type group_C[] = {
    GROUPC, NULL
};

some_type group_D[] = {
    GROUPD, NULL
};

#undef GROUPA
#undef GROUPB
#undef GROUPC
#undef GROUPD

---

我认为这是一个完美的例子，可以使用宏来避免代码重复，同时又不牺牲代码的清晰度。

对其他数组的引用是只出现在开头，还是可以出现在任何地方？@interjay它可以被限制为只出现在开头，是的。当你说“禁止递归”时，你是指无限递归吗？因为你提出的问题本质上是递归的。@interjay是的，没有无限递归。嗯，是的-可能。我需要再想一想。@tchrist真是太遗憾了=/当我想到其他事情时，你能解释一下这些原因吗？：）干得好-D+1

#define GROUPA elt0, elt1, elt2, elt3
#define GROUPB GROUPA, elt4, elt5
#define GROUPC GROUPA, elt6, elt7, elt8
#define GROUPD GROUPB, elt9, elt10, elt11

some_type group_A[] = {
    GROUPA, NULL
};

some_type group_B[] = {
    GROUPB, NULL
};

some_type group_C[] = {
    GROUPC, NULL
};

some_type group_D[] = {
    GROUPD, NULL
};

#undef GROUPA
#undef GROUPB
#undef GROUPC
#undef GROUPD