Struct declaration

结构体是一种由成员序列组成的类型，其存储空间按有序序列分配（与联合体相反，联合体是由存储空间重叠的成员序列组成的类型）。

结构体的 类型说明符 与 union 类型说明符完全相同，唯一的区别在于所使用的关键字：

语法

说明

在结构体对象内部，其元素的地址（以及位域分配单元的地址）按照成员定义的顺序递增。指向结构体的指针可以强制转换为指向其首个成员的指针（或者，如果成员是位域，则转换为指向其分配单元的指针）。同样地，指向结构体首个成员的指针也可以强制转换为指向该结构体的指针。结构体的任意两个成员之间或最后一个成员之后可能存在未命名的填充字节，但第一个成员之前不会有填充。结构体的大小至少等于其所有成员大小之和。

struct s { int n; double d[]; }; // s.d is a flexible array member
struct s t1 = { 0 };          // OK, d is as if double d[1], but UB to access
struct s t2 = { 1, { 4.2 } }; // error: initialization ignores flexible array
// if sizeof (double) == 8
struct s *s1 = malloc(sizeof (struct s) + 64); // as if d was double d[8]
struct s *s2 = malloc(sizeof (struct s) + 40); // as if d was double d[5]
s1 = malloc(sizeof (struct s) + 10); // now as if d was double d[1]. Two bytes excess.
double *dp = &(s1->d[0]);    // OK
*dp = 42;                    // OK
s1->d[1]++;                  // Undefined behavior. 2 excess bytes can't be accessed
                             // as double.
s2 = malloc(sizeof (struct s) + 6);  // same, but UB to access because 2 bytes are
                                     // missing to complete 1 double
dp = &(s2->d[0]);            // OK, can take address just fine
*dp = 42;                    // undefined behavior
*s1 = *s2; // only copies s.n, not any element of s.d
           // except those caught in sizeof (struct s)

struct v
{
   union // anonymous union
   {
      struct { int i, j; }; // anonymous structure
      struct { long k, l; } w;
   };
   int m;
} v1;
v1.i = 2;   // valid
v1.k = 3;   // invalid: inner structure is not anonymous
v1.w.k = 5; // valid

前向声明

以下形式的声明

隐藏先前在标签命名空间中声明的名称 name 的所有含义，并在当前作用域中将 name 声明为稍后定义的新结构体名称。在定义出现之前，该结构体名称具有 不完整类型 。

这允许结构体相互引用：

struct y;
struct x { struct y *p; /* ... */ };
struct y { struct x *q; /* ... */ };

注意，新的结构体名称也可以通过在其他声明中使用结构体标签来引入，但如果标签 命名空间 中已存在同名的先前声明的结构体，该标签将引用该名称

struct s* p = NULL; // 使用结构体标签声明未知结构体
struct s { int a; }; // p所指向结构体的定义
void g(void)
{
    struct s; // 新局部结构体s的前向声明
              // 这将隐藏全局结构体s直至当前块结束
    struct s *p;  // 指向局部结构体s的指针
                  // 若无上述前向声明
                  // 此指针将指向文件作用域的s
    struct s { char* p; }; // 局部结构体s的定义
}

关键词

struct

注释

请参阅 结构体初始化 了解有关结构体初始化器的规则。

由于不允许使用不完整类型的成员，且结构体类型直到定义结束才变得完整，因此结构体不能拥有其自身类型的成员。允许使用指向自身类型的指针，这通常用于实现链表或树中的节点。

由于结构体声明不会建立 作用域 ，在 struct-declaration-list 内部声明引入的嵌套类型、枚举和枚举项在定义该结构体的外围作用域中可见。

示例

#include <stddef.h>
#include <stdio.h>
int main(void)
{
    // 声明结构体类型
    struct car
    {
        char* make;
        int year;
    };
    // 声明并初始化先前声明的结构体类型的对象
    struct car c = {.year = 1923, .make = "Nash"};
    printf("1) Car: %d %s\n", c.year, c.make);
    // 声明结构体类型、该类型的对象及其指针
    struct spaceship
    {
        char* model;
        int max_speed;
    } ship = {"T-65 X-wing starfighter", 1050},
    *pship = &ship;
    printf("2) Spaceship: %s. Max speed: %d km/h\n\n", ship.model, ship.max_speed);
    // 地址按定义顺序递增，可能会插入填充字节
    struct A { char a; double b; char c; };
    printf(
        "3) Offset of char a = %zu\n"
        "4) Offset of double b = %zu\n"
        "5) Offset of char c = %zu\n"
        "6) Size of struct A = %zu\n\n",
        offsetof(struct A, a),
        offsetof(struct A, b),
        offsetof(struct A, c),
        sizeof(struct A)
    );
    struct B { char a; char b; double c; };
    printf(
        "7) Offset of char a = %zu\n"
        "8) Offset of char b = %zu\n"
        "9) Offset of double c = %zu\n"
        "A) Size of struct B = %zu\n\n",
        offsetof(struct B, a),
        offsetof(struct B, b),
        offsetof(struct B, c),
        sizeof(struct B)
    );
    // 结构体指针可强制转换为指向其首成员的指针，反之亦然
    char** pmodel = (char **)pship;
    printf("B) %s\n", *pmodel);
    pship = (struct spaceship *)pmodel;
}

1) Car: 1923 Nash
2) Spaceship: T-65 X-wing starfighter. Max speed: 1050 km/h
3) Offset of char a = 0
4) Offset of double b = 8
5) Offset of char c = 16
6) Size of struct A = 24
7) Offset of char a = 0
8) Offset of char b = 1
9) Offset of double c = 8
A) Size of struct B = 16
B) T-65 X-wing starfighter

缺陷报告

以下行为变更缺陷报告被追溯应用于先前发布的C语言标准。

参考文献

另请参阅

• 结构体与联合体成员访问
• 位域
• 结构体初始化