结构
约 3194 字大约 11 分钟
2023-05-30
结构体
C 数组允许定义可存储相同类型数据项的变量，结构体是 C 编程中另一种用户自定义的可用的数据类型，它允许存储不同类型的数据项。
结构体用于表示一条记录，如果想要跟踪图书馆中书本的动态，可能需要跟踪每本书的下列属性：
- Title
- Author
- Subject
- Book ID
定义结构体
定义结构体必须使用 struct 语句。struct 语句定义了一个包含多个成员的新的数据类型，struct 语句的格式如下：
struct [structure tag]
{
member definition;
member definition;
...
member definition;
} [one or more structure variables];structure tag 是可选的，每个 member definition 是标准的变量定义，比如 int i; 或者 float f; 或者其他有效的变量定义。在结构定义的末尾，最后一个分号之前，可以指定一个或多个结构变量，这是可选的。下面是声明 Book 结构的方式：
struct Books
{
char title[50];
char author[50];
char subject[100];
int book_id;
} book;访问结构成员
为了访问结构的成员，使用成员访问运算符（.）。成员访问运算符是结构变量名称和要访问的结构成员之间的一个句号。可以使用 struct 关键字来定义结构类型的变量。下面的实例演示了结构的用法：
#include <stdio.h>
#include <string.h>
struct Books
{
char title[50];
char author[50];
char subject[100];
int book_id;
};
int main()
{
struct Books Book1; /* 声明 Book1，类型为 Book */
struct Books Book2; /* 声明 Book2，类型为 Book */
/* Book1 详述 */
strcpy(Book1.title, "C Programming");
strcpy(Book1.author, "Nuha Ali");
strcpy(Book1.subject, "C Programming Tutorial");
Book1.book_id = 6495407;
/* Book2 详述 */
strcpy(Book2.title, "Telecom Billing");
strcpy(Book2.author, "Zara Ali");
strcpy(Book2.subject, "Telecom Billing Tutorial");
Book2.book_id = 6495700;
/* 输出 Book1 信息 */
printf("Book 1 title : %s\n", Book1.title);
printf("Book 1 author : %s\n", Book1.author);
printf("Book 1 subject : %s\n", Book1.subject);
printf("Book 1 book_id : %d\n", Book1.book_id);
/* 输出 Book2 信息 */
printf("Book 2 title : %s\n", Book2.title);
printf("Book 2 author : %s\n", Book2.author);
printf("Book 2 subject : %s\n", Book2.subject);
printf("Book 2 book_id : %d\n", Book2.book_id);
return 0;
}当上面的代码被编译和执行时，会产生下列结果：
Book 1 title : C Programming
Book 1 author : Nuha Ali
Book 1 subject : C Programming Tutorial
Book 1 book_id : 6495407
Book 2 title : Telecom Billing
Book 2 author : Zara Ali
Book 2 subject : Telecom Billing Tutorial
Book 2 book_id : 6495700结构作为函数参数
可以把结构作为函数参数，传参方式与其他类型的变量或指针类似。可以使用上面实例中的方式来访问结构变量：
#include <stdio.h>
#include <string.h>
struct Books
{
char title[50];
char author[50];
char subject[100];
int book_id;
};
/* 函数声明 */
void printBook(struct Books book);
int main()
{
struct Books Book1; /* 声明 Book1，类型为 Book */
struct Books Book2; /* 声明 Book2，类型为 Book */
/* Book1 详述 */
strcpy(Book1.title, "C Programming");
strcpy(Book1.author, "Nuha Ali");
strcpy(Book1.subject, "C Programming Tutorial");
Book1.book_id = 6495407;
/* Book2 详述 */
strcpy(Book2.title, "Telecom Billing");
strcpy(Book2.author, "Zara Ali");
strcpy(Book2.subject, "Telecom Billing Tutorial");
Book2.book_id = 6495700;
/* 输出 Book1 信息 */
printBook(Book1);
/* 输出 Book2 信息 */
printBook(Book2);
return 0;
}
void printBook(struct Books book)
{
printf("Book title : %s\n", book.title);
printf("Book author : %s\n", book.author);
printf("Book subject : %s\n", book.subject);
printf("Book book_id : %d\n", book.book_id);
}当上面的代码被编译和执行时，会产生下列结果：
Book title : C Programming
Book author : Nuha Ali
Book subject : C Programming Tutorial
Book book_id : 6495407
Book title : Telecom Billing
Book author : Zara Ali
Book subject : Telecom Billing Tutorial
Book book_id : 6495700指向结构的指针
可以定义指向结构的指针，方式与定义指向其他类型变量的指针相似，如下所示：
struct Books *struct_pointer;可以在上述定义的指针变量中存储结构变量的地址。为了查找结构变量的地址，把 & 运算符放在结构名称的前面，如下所示：
struct_pointer = &Book1;为了使用指向该结构的指针访问结构的成员，必须使用 -> 运算符，如下所示：
struct_pointer->title;使用结构指针来重写上面的实例：
#include <stdio.h>
#include <string.h>
struct Books
{
char title[50];
char author[50];
char subject[100];
int book_id;
};
/* 函数声明 */
void printBook(struct Books* book);
int main()
{
struct Books Book1; /* 声明 Book1，类型为 Book */
struct Books Book2; /* 声明 Book2，类型为 Book */
/* Book1 详述 */
strcpy(Book1.title, "C Programming");
strcpy(Book1.author, "Nuha Ali");
strcpy(Book1.subject, "C Programming Tutorial");
Book1.book_id = 6495407;
/* Book2 详述 */
strcpy(Book2.title, "Telecom Billing");
strcpy(Book2.author, "Zara Ali");
strcpy(Book2.subject, "Telecom Billing Tutorial");
Book2.book_id = 6495700;
/* 通过传 Book1 的地址来输出 Book1 信息 */
printBook(&Book1);
/* 通过传 Book2 的地址来输出 Book2 信息 */
printBook(&Book2);
return 0;
}
void printBook(struct Books* book)
{
printf("Book title : %s\n", book->title);
printf("Book author : %s\n", book->author);
printf("Book subject : %s\n", book->subject);
printf("Book book_id : %d\n", book->book_id);
}当上面的代码被编译和执行时，会产生下列结果：
Book title : C Programming
Book author : Nuha Ali
Book subject : C Programming Tutorial
Book book_id : 6495407
Book title : Telecom Billing
Book author : Zara Ali
Book subject : Telecom Billing Tutorial
Book book_id : 6495700联合
联合是一种特殊的数据类型，允许在相同的内存位置存储不同的数据类型。可以定义一个带有多成员的联合，但是任何时候只能有一个成员带有值。联合提供了一种使用相同的内存位置的有效方式。
定义联合
为了定义联合，必须使用 union 语句，方式与定义结构类似。union 语句定义了一个新的数据类型，带有多个成员。union 语句的格式如下：
union [union tag]
{
member definition;
member definition;
...
member definition;
} [one or more union variables];union tag 是可选的，每个 member definition 是标准的变量定义，比如 int i; 或者 float f; 或者其他有效的变量定义。在联合定义的末尾，最后一个分号之前，可以指定一个或多个联合变量，这是可选的。下面定义一个名为 Data 的联合类型，有三个成员 i、f 和 str：
union Data
{
int i;
float f;
char str[20];
} data;现在 Data 类型的变量可以存储一个整数、一个浮点数，或者一个字符串。这意味着一个变量（相同的内存位置）可以存储多个多种类型的数据。可以根据需要在一个联合内使用任何内置的或者用户自定义的数据类型。
联合占用的内存应足够存储联合中最大的成员。例如，在上面的实例中，Data 将占用 20 个字节的内存空间，因为在各个成员中，字符串所占用的空间是最大的。下面的实例将显示上面的联合占用的总内存大小：
#include <stdio.h>
#include <string.h>
union Data
{
int i;
float f;
char str[20];
};
int main()
{
union Data data;
printf("Memory size occupied by data : %d\n", sizeof(data));
return 0;
}当上面的代码被编译和执行时，会产生下列结果：
Memory size occupied by data : 20访问联合成员
为了访问联合的成员，使用成员访问运算符（.）。成员访问运算符是联合变量名称和要访问的联合成员之间的一个句号。可以使用 union 关键字来定义联合类型的变量。下面的实例演示了联合的用法：
#include <stdio.h>
#include <string.h>
union Data
{
int i;
float f;
char str[20];
};
int main( )
{
union Data data;
data.i = 10;
data.f = 220.5;
strcpy(data.str, "C Programming");
printf( "data.i : %d\n", data.i);
printf( "data.f : %f\n", data.f);
printf( "data.str : %s\n", data.str);
return 0;
}当上面的代码被编译和执行时，会产生下列结果：
data.i : 1917853763
data.f : 4122360580327794860452759994368.000000
data.str : C Programming在这里，可以看到联合的 i 和 f 成员的值有损坏，因为最后赋给变量的值占用了内存位置，这也是 str 成员能够完好输出的原因。再来看一个相同的实例，这次在同一时间只使用一个变量，这也演示了使用联合的主要目的：
#include <stdio.h>
#include <string.h>
union Data
{
int i;
float f;
char str[20];
};
int main()
{
union Data data;
data.i = 10;
printf("data.i : %d\n", data.i);
data.f = 220.5;
printf("data.f : %f\n", data.f);
strcpy(data.str, "C Programming");
printf("data.str : %s\n", data.str);
return 0;
}当上面的代码被编译和执行时，会产生下列结果：
data.i : 10
data.f : 220.500000
data.str : C Programming在这里，所有的成员都能完好输出，因为同一时间只用到一个成员。
位域
如果程序的结构中包含多个开关量，只有 TRUE/FALSE 变量，如下：
struct
{
unsigned int widthValidated;
unsigned int heightValidated;
} status;这种结构需要 8 字节的内存空间，但在实际上，在每个变量中，只存储 0 或 1。在这种情况下，C 语言提供了一种更好的利用内存空间的方式。如果在结构内使用这样的变量，可以定义变量的宽度来告诉编译器，将只使用这些字节。例如，上面的结构可以重写成：
struct
{
unsigned int widthValidated : 1;
unsigned int heightValidated : 1;
} status;现在，上面的结构中，status 变量将占用 4 个字节的内存空间，但是只有 2 位被用来存储值。如果用了 32 个变量，每一个变量宽度为 1 位，那么 status 结构将使用 4 个字节，但只要再多用一个变量，如果使用了 33 个变量，那么它将分配内存的下一段来存储第 33 个变量，这个时候就开始使用 8 个字节。看看下面的实例来理解这个概念：
#include <stdio.h>
#include <string.h>
/* 定义简单的结构 */
struct
{
unsigned int widthValidated;
unsigned int heightValidated;
} status1;
/* 定义位域结构 */
struct
{
unsigned int widthValidated : 1;
unsigned int heightValidated : 1;
} status2;
int main()
{
printf("Memory size occupied by status1 : %d\n", sizeof(status1));
printf("Memory size occupied by status2 : %d\n", sizeof(status2));
return 0;
}当上面的代码被编译和执行时，会产生下列结果：
Memory size occupied by status1 : 8
Memory size occupied by status2 : 4位域声明
在结构内声明位域的形式如下：
struct
{
type [member_name] : width ;
};下面是有关位域中变量元素的描述：
| 元素 | 描述 |
|---|---|
| type | 整数类型，决定了如何解释位域的值。类型可以是整型、有符号整型、无符号整型。 |
| member_name | 位域的名称。 |
| width | 位域中位的数量。宽度必须小于或等于指定类型的位宽度。 |
带有预定义宽度的变量被称为位域。位域可以存储多于 1 位的数，例如，需要一个变量来存储从 0 到 7 的值，可以定义一个宽度为 3 位的位域，如下：
struct
{
unsigned int age : 3;
} Age;上面的结构定义指示 C 编译器，age 变量将只使用 3 位来存储这个值，如果试图使用超过 3 位，则无法完成。下面的实例：
#include <stdio.h>
#include <string.h>
struct
{
unsigned int age : 3;
} Age;
int main()
{
Age.age = 4;
printf("Sizeof(Age) : %d\n", sizeof(Age));
printf("Age.age : %d\n", Age.age);
Age.age = 7;
printf("Age.age : %d\n", Age.age);
Age.age = 8;
printf("Age.age : %d\n", Age.age);
return 0;
}当上面的代码被编译时，会带有警告，当上面的代码被执行时，会产生下列结果：
Sizeof(Age) : 4
Age.age : 4
Age.age : 7
Age.age : 0位域的使用
位域的使用和结构成员的使用相同，其一般形式为：
位域变量名·位域名看下面的实例：
int main()
{
struct bs
{
unsigned a : 1;
unsigned b : 3;
unsigned c : 4;
} bit, *pbit;
bit.a = 1; /* 给位域赋值（应注意赋值不能超过该位域的允许范围） */
bit.b = 7; /* 给位域赋值（应注意赋值不能超过该位域的允许范围） */
bit.c = 15; /* 给位域赋值（应注意赋值不能超过该位域的允许范围） */
printf("%d,%d,%d\n", bit.a, bit.b, bit.c); /* 以整型量格式输出三个域的内容 */
pbit = &bit; /* 把位域变量 bit 的地址送给指针变量 pbit */
pbit->a = 0; /* 用指针方式给位域 a 重新赋值，赋为 0 */
pbit->b &= 3; /* 使用了复合的位运算符 "&="，相当于：pbit->b=pbit->b&3，位域 b 中原有值为 7，与 3 作按位与运算的结果为 3（111&011=011，十进制值为 3） */
pbit->c |= 1; /* 使用了复合位运算符"|="，相当于：pbit->c=pbit->c|1，其结果为 15 */
printf("%d,%d,%d\n", pbit->a, pbit->b, pbit->c); /* 用指针方式输出了这三个域的值 */
}上例程序中定义了位域结构 bs，三个位域为 a、b、c。说明了 bs 类型的变量 bit 和指向 bs 类型的指针变量 pbit。这表示位域也是可以使用指针的。