结构和联合

结构或联合成员可以是任何类型，但以下类型除外:

• 任何可变修改类型
• void 类型
• 功能
• 任何不完整类型

由于不允许不完整的类型作为成员，因此结构或并集类型可能不包含自身作为成员的实例，但允许包含指向自身实例的指针。 作为一种特殊情况，具有多个成员的结构的最后一个成员可能具有不完整的数组类型，称为 弹性数组成员，如 弹性数组成员中所述。

作为 标准C和C++ 的扩展，与 GNU C/C++ 兼容， XL C/C++ 还允许零范围数组作为结构和联合体的成员，如零范围数组成员（ IBM 扩展） 中所述。

灵活数组成员

柔性阵列成员 是 在结构中出现的无界阵列。 这是一个 C99 功能， XL C/C++ 编译器支持它作为 IBM 扩展。 可使用灵活的数组成员来访问可变长度对象。 允许柔性阵列成员作为结构的最后一个成员，前提是该结构具有多个指定成员。 它使用空索引进行声明，如下所示:

array_identifier [];

例如， b 是结构 f的灵活数组成员。

struct f{
  int a;
  int b[];
};

由于弹性阵列成员的类型不完整，因此无法将 sizeof 运算符应用于弹性阵列。 在此示例中，语句 sizeof(f) 返回与 sizeof(f.a)相同的结果，即整数的大小。 无法使用语句 sizeof(f.b) ，因为 b 是类型不完整的灵活数组成员。

任何包含灵活数组成员的结构都不能是另一个结构的成员或数组的元素，例如:

struct f{
  int a;
  int b[];
};
struct f fa[10]; // Error.

为了与GNU C/C++ 兼容， XL C/C++ 编译器扩展了标准C 和C++ ，以放宽对灵活数组成员的约束，并允许以下情况：

• 可以在结构的任何部分中声明柔性阵列成员，而不仅仅是最后一个成员。 跟在柔性阵列成员后面的任何成员的类型都不需要与柔性阵列成员的类型兼容; 但是，当柔性阵列成员跟在不兼容类型的成员后面时，会发出警告消息。 以下示例对此进行了演示:

  struct s {
    int a;
    int b[];
    char c; // The compiler issues a warning message.
  } f;

• 包含柔性阵列成员的结构可以是其他结构的成员。
• 只有满足以下两个条件之一时，才能对弹性阵列成员进行静态初始化：
  • 柔性阵列成员是结构的最后一个成员，例如:

    struct f { 
      int a;
      int b[];
    } f1 = {1,{1,2,3}}; // Fine.
    
    struct a {    
      int b;
      int c[];
      int d[];
    } e = { 1,{1,2},3}; // Error, c is not the last member
                        // of structure a.
    

  • 柔性数组成员包含在嵌套结构的最外层结构中。 内部结构的成员不能以静态方式初始化，例如:

    struct b {
      int c;
      int d[]; 
    }; 
    
    struct c { 
      struct b f;
      int g[]; 
    } h ={{1,{1,2}},{1,2}}; // Error, member d of structure b is
                            // in the inner nested structure.
    

  

零扩展数据块阵列成员 (IBM 扩展)

零扩展数据块数组是为了实现 GNU C/C++ 兼容性而提供的，可用于访问变长对象。

零扩展数据块数组是指定为其维的显式零的数组。

array_identifier [0]

例如， b 是结构 f的零扩展数据块数组成员。

struct f{
  int a;
  int b[0];
};

sizeof 运算符可以应用于零扩展数据块数组，返回的值为 0。 在此示例中，语句 sizeof(f) 返回与 sizeof(f.a)相同的结果，后者是整数的大小。 语句 sizeof(f.b) 返回 0。

包含零扩展数据块数组的结构可以是数组的元素，例如:

struct f{
  int a;
  int b[0];
};
struct f fa[10]; // Fine.

零扩展数据块数组只能使用空集 {}静态初始化。 否则，必须将其初始化为动态分配的阵列。 例如：

struct f{
  int a;
  int b[0];
};
struct f f1 = {100, {}}; //Fine.
struct f f2 = {100, {1, 2}}; //Error.

如果未初始化零扩展数据块数组，那么不会进行静态零填充，因为零扩展数据块数组定义为没有成员。 以下示例对此进行了演示:

#include <stdio.h>

struct s {
  int a;
  int b[0];
};

struct t1 {
  struct s f;
  int c[3];
} g1 = {{1},{1,2}};

struct t2 {
  struct s f;
  int c[3];
} g2 = {{1,{}},{1,2}};

int main() {
  printf("%d %d %d %d\n", g1.f.a, g1.f.b[0], g1.f.b[1], g1.f.b[2]);
  printf("%d %d %d %d\n", g2.f.a, g2.f.b[0], g2.f.b[1], g2.f.b[2]);
  return 0;
} 

在此示例中，两个 printf 语句生成相同的输出:

1 1 2 0

可以在结构的任何部分中声明零扩展数据块数组，而不仅仅是最后一个成员。 零扩展数据块阵列之后的任何成员的类型都不需要与零扩展数据块阵列的类型兼容; 但是， 当零扩展数据块阵列后跟不兼容类型的成员时， 会发出警告。 例如：

struct s {
  int a;
  int b[0];
  char c;    // Issues a warning message
} f;

只能将零扩展数据块数组声明为聚集类型的成员。 例如：

int func(){
  int a[0];        // error
  struct S{
    int x;
    char b[0];     // fine
  };
}

位字段成员

C 和 C++ 都允许将整数成员存储到比编译器通常允许的更小的内存空间中。 这些节省空间的结构成员称为 位字段，它们的宽度 (以位计) 可以显式声明。 位字段用于必须强制数据结构与固定硬件表示相对应且不可移植的程序中。

在 C99中，位字段的允许数据类型包括 _Bool， int， signed int和 unsigned int。 位域的数据类型也可以是任何版本的 char、 short 和 long。 如果某个位字段的类型为 char 或 short的任何版本，那么其类型将由 signed int 或 unsigned int替换，具体取决于 -qbitfields的设置。 如果位字段是纯文本 或纯文本 ，则位字段是 还是 取决于 的设置。 int long signed unsigned -qbitfields

以下结构具有三个位字段成员 kingdom, phylum和 genus，分别占 12 位， 6 位和 2 位:

struct taxonomy {
  int kingdom : 12;
  int phylum : 6;
  int genus : 2;
};

以下限制适用于位字段。 您不能:

• 定义位字段数组
• 采用位字段的地址
• 有一个指向位字段的指针
• 具有对位字段的引用

位字段是位打包的。 它们可以跨越字和字节边界。 在两个 (非零长度) 位字段成员之间未插入任何填充。 如果下一个成员是长度为零的位字段或非位字段，那么可以在位字段成员之后进行位填充。 非位字段成员根据其声明的类型进行对齐。 例如，以下结构演示了位字段成员之间缺少填充，以及在非位字段成员之前的位字段成员之后插入填充。

struct {
  int larry : 25;	// Bit Field: offset 0 bytes and 0 bits.
  int curly : 25;	// Bit Field: offset 3 bytes and 1 bit (25 bits).
  int moe;        // non-Bit Field: offset 8 bytes and 0 bits (64 bits).
} stooges;

larry 和 curly之间没有填充。 curly 的位偏移量将为 25 位。 成员 moe 将在下一个 4 字节边界上对齐，从而在 curly 和 moe之间产生 14 位填充。

以下示例演示了填充，并且对所有实现都有效。 假设 int 占用 4 个字节。 此示例声明标识 kitchen 的类型为 struct on_off:

struct on_off {
  unsigned light : 1;
  unsigned toaster : 1;
  int count; /* 4 bytes */
  unsigned ac : 4;
  unsigned : 4;
  unsigned clock : 1;
  unsigned : 0;
  unsigned flag : 1;
} kitchen;

结构 kitchen 包含 8 个成员，总计 16 个字节。 下表描述了每个成员占用的存储器:

以下示例定义了结构类型 address:

struct address {
  int street_no;
  char *street_name;
  char *city;
  char *prov;
  char *postal_code;
};
     

以下示例声明两个类型为 address的结构变量:

struct address perm_address;
struct address temp_address;      

可以在一个语句中定义结构 (或并集) 类型和结构 (或并集) 变量，方法是将声明符和可选初始化方法放在变量定义之后。 以下示例定义并集数据类型 (未命名) 和并集变量 (名为 length):

union {
  float meters;
  double centimeters;
  long inches;
} length;

要指定一个或多个变量的存储类说明符，必须将存储类说明符放在语句的开头。 例如：

static struct {
  int street_no;
  char *street_name;
  char *city;
  char *prov;
  char *postal_code;
} perm_address, temp_address;

在这种情况下，将同时为 perm_address 和 temp_address 分配静态存储器。

类型限定符可以应用于类型定义中声明的一个或多个变量。 以下两个示例都有效:

volatile struct class1 {
  char descript[20];
  long code;
  short complete;
} file1, file2;

struct class1 {
  char descript[20];
  long code;
  short complete;
} volatile file1, file2;

声明结构或并集变量后，将通过使用点运算符 (.) 指定变量名或使用箭头运算符 (->) 和成员名指定指针来引用成员。 例如，以下两项:

perm_address.prov = "Ontario";
p_perm_address -> prov = "Ontario";

将字符串 "Ontario" 分配给结构 perm_address中的指针 prov 。

匿名结构 是没有标记或名称且是另一个结构或并集的成员的结构。 匿名结构的所有成员的行为就像它们是父结构的成员一样。 匿名结构必须满足以下条件:

• 该结构嵌套在另一个结构或并集内。
• 该结构没有标记。
• 结构没有名称。

例如，以下代码片段演示匿名结构必须满足的条件。

struct v {
  union {
     // This is an anonymous structure, because it has no tag, no name,
     // and is a member of another structure or union.
     struct { int i, j; };

     // This is not an anonymous structure, because it has a name.
     struct { long k, l; } w; 

    // This is not an anonymous structure, because
    // the structure has a tag "phone".
    struct phone {int number, areanumber;};  
  };
  
  int m;
} v1;

例如，在以下代码片段中，您可以直接访问数据成员 i 和 cptr ，因为它们位于包含匿名联合的作用域中。 由于 i 和 cptr 是并集成员并且具有相同的地址，因此一次只能使用其中一个成员。 对成员 cptr 的分配将更改成员 i的值。

void f() {
  union { int i; char* cptr ; };
  /* . . . */
  i = 5;
  cptr = "string_in_union"; // Overrides the value 5.
}