C Primer Plus学习笔记（十三）- 结构和其他数据形式
建立结构声明
结构声明（structure declaration）描述了一个结构的组织布局
struct book
{
char title[MAXTITL];
char author[MAXAUTL];
float value;
};
该声明描述了一个由两个字符数组和一个 float 类型变量组成的结构。该声明并未创建实际的数据对象，只描述了该对象由什么组成
关键字 struct，它表明跟在其后的是一个结构，后面是一个可选的标记（该例中是 book），程序中可以使用该标记引用该结构
在结构声明中，用一对花括号括起来的是结构成员列表。
每个成员都用自己的声明来描述，例如，title 部分是一个内含 MAXTITL 个元素的 char 类型数组
成员可以是任意一种 C 的数据结构，甚至可以是其他结构
右花括号后面的分号是声明所必需的，表示结构布局定义结束
struct book library;
这把 library 声明为一个使用 book 结构布局的结构变量
可以把这个声明放在所有函数的外部，也可以放在一个函数定义的内部
如果把结构声明置于一个函数的内部，它的标记就只限于该函数内部使用
如果把结构声明置于函数的外部，声明结构之后的所有函数都能使用它的标记
例如，在程序的另一个函数中，可以这样声明
struct book dickens;
该函数便创建了一个结构变量 dickens，该变量的结构布局是 book
结构的标记名是可选的
定义结构变量
结构有两层含义
一层含义是“结构布局”，结构布局告诉编译器如何表示数据，但是它并未让编译器为数据分配空间
另一层含义是创建一个结构变量
struct book library;
编译器执行这行代码便创建了一个结构变量 library，编译器使用 book 模板为该变量分配空间
在结构变量的声明中，struct book 所起的作用相当于一般声明中的 int 或 float
struct book library;
相当于
struct book
{
char title[MAXTITL];
char author[MAXAUTL];
float value;
} library; // 声明的右花括号后跟变量名
声明结构的过程和定义结构变量的过程可以组合成一个步骤
组合后的结构声明和结构变量定义不需要使用结构标记
struct // 无结构标记
{
char title[MAXTITL];
char author[MAXAUTL];
float value;
} library;
初始化结构
初始化一个结构变量（ANSI 之前，不能用自动变量初始化结构，ANSI 之后可以用任意存储类别）与初始化数组的语法类似
struct book library = {
"Hello World",
"Jack",
22.1
};
使用在一对花括号中括起来的初始化列表进行初始化，各初始化项用逗号分隔
如果初始化静态存储期的变量（如，静态外部链接、静态内部链接或静态无链接），必须使用常量值，这同样适用于结构。如果初始化一个静态存储期的结构，初始化列表中的值必须是常量表达式。如果是自动存储期，初始化列表中的值可以不是常量
访问结构成员
使用结构成员运算符——点（.）访问结构中的成员
例如，library.value 即访问 library 的 value 部分。虽然 library 是一个结构，但是 library.value 是一个 float 类型的变量，可以像使用其他 float 类型变量那样使用它
. 比 & 的优先级高
结构的初始化器
C99 和 C11 为结构提供了指定初始化器（designated initializer），其语法与数组的指定初始化器类似
结构的指定初始化器使用点运算符和成员名（而不是方括号和下标）标识特定的元素
例如，只初始化 book 结构 value 成员
struct book library = {.value = 10.99}；
可以按照任意顺序使用指定初始化器
struct book library = {
.title = "Hello World",
.value = 10.99,
.author = "Jack"
};
与数组类似，在指定初始化器后面的普通初始化器，为指定成员后面的成员提供初始值
对特定成员的最后一次赋值才是它实际获得的值
struct book library = {
.value = 10.99,
.author = "Jack",
22.55
};
value 最后的值为 22.55
结构数组
声明结构数组
声明结构数组和声明其它类型的数组类似
struct book library[MAXBKS];
把 library 声明为一个内含 MAXBKS 个元素的数组，数组的每个元素都是一个 book 类型的数组
数组名 library 本身不是结构名，它是一个数组名，该数组中的每个元素都是 struct book 类型的结构变量
标识结构数组的成员
标识结构数组中的成员，可以采用访问单独结构的规则：在结构名后面加一个点运算符，再在点运算符后面写上成员名
library[0].value // 第 1 个数组元素与 value 相关联 library[4].title // 第 5 个数组元素与 title 相关联
数组下标是在 library 后面，不是在成员名后面
使用 library[2].value 的原因是，library[2] 是结构变量名
library[2].title[4] 的意思是，library 数组第 3 个结构变量中 title 的第 5 个字符
总结一下：
library // 一个 book 结构的数组 library[2] // 一个数组元素，该元素是 book 结构 library[2].title // 一个 char 数组（library[2] 的 title 成员） library[2].title[4] // 数组中 library[2] 元素的 title 成员的第 5 个字符
嵌套结构
在一个结构中包含另一个结构
#include <stdio.h>
#define LEN 20
const char * msgs[5] = {
" Thank you for the wonderful evening, ",
"You certainly prove that a ",
"is a special kind of guy. We must get together",
"over a delicious ",
" and have a few laughs"
};
struct names { // 第 1 个结构
char first[LEN];
char last[LEN];
};
struct guy { // 第 2 个结构
struct names handle; // 嵌套结构
char favfood[LEN];
char job[LEN];
float income;
};
int main(void){
struct guy fellow = {
{"Ewen", "Villard"},
"grilled salmon",
"personality coach",
68112.00
};
printf("Dear %s, \n\n", fellow.handle.first);
printf("%s%s.\n", msgs[0], fellow.handle.first);
printf("%s%s\n", msgs[1], fellow.job);
printf("%s\n", msgs[2]);
printf("%s%s%s\n", msgs[3], fellow.favfood, msgs[4]);
if (fellow.income > 150000.0)
puts("!!");
else if (fellow.income > 75000.0)
puts("!");
else
puts(".");
printf("\n%40s%s\n", " ", "See you soon,");
printf("%40s%s\n", " ", "Shalala");
return 0;
}
运行结果
访问嵌套结构的成员，需要使用两次点运算符
指向结构的指针
就像指向数组的指针比数组本身更容易操纵（如，排序问题）一样，指向结构的指针通常比结构本身更容易操纵
在一些早期的 C 实现中，结构不能作为参数传递给函数，但是可以传递指向其他结构的指针
即使能传递一个结构，传递指针通常更有效率
一些用于表示数据的结构中包含指向其他结构的指针
#include <stdio.h>
#define LEN 20
struct names {
char first[LEN];
char last[LEN];
};
struct guy {
struct names handle;
char favfood[LEN];
char job[LEN];
float income;
};
int main(void){
struct guy fellow[2] = {
{
{"Eween", "Villard"},
"grilled salmon",
"personality coach",
68112.00
},
{
{"Rodeny", "Swillbelly"},
"tripe",
"tabloid editor",
432400.00
}
};
struct guy * him; // 这是一个指向结构的指针
printf("address #1: %p #2: %p\n", &fellow[0], &fellow[1]);
him = &fellow[0]; // 告诉编译器指针该指向何处
printf("pointer #1: %p #2: %p\n", him, him + 1);
printf("him->income is $%.2f: (*him).income is $%.2f\n",
him->income, (*him).income);
him++; // 指向下一个结构
printf("him->favfood is %s: him->handle.last is %s\n",
him->favfood, him->handle.last);
return 0;
}
运行结果
声明和初始化结构指针
struct guy * him;
首先是关键字 struct，其次是结构标记 guy，然后是一个星号（*），其后跟着指针名
该声明并未创建一个新的结构，但是指针 him 现在可以指向任意现有的 guy 类型的结构
例如，如果 barney 是一个 guy 类型的结构变量，可以这样写
him = &barney;
结构变量名不是结构的地址，因此要在结构变量名前面加上 & 运算符
在上面代码中 fellow 是一个结构数组，这意味着 fellow[0] 是一个结构。要让 him 指向 fellow[0]，可以这样写：
him = &fellow[0];
him 指向 fellow[0]，him + 1 指向 fellow[1]
him 加 1相当于 him 指向的地址加 84
在十六进制中，874 - 820 = 54（十六进制）= 84（十进制）
因为每个 guy 结构都占用 84 字节的内存：name.first 占用 20 字节，name.last 占用 20 字节，favfood 占用 20 字节，job 占用 20 字节，income 占用 4 字节（float 占用 4 字节）
用指针访问成员
第 1 种方法是：使用 -> 运算符，该运算符由一个连接号（-）后跟一个大于号（>）组成
如果 him == &barney，那么 him->income 即是 barney.income 如果 him == &fellow[0]，那么 him->income 即是 fellow[0].income
第 2 种方法是：以这样的顺序指定结构成员的值，如果 him == &fellow[0]，那么 *him == fellow[0]，因为 & 和 * 是一对互逆运算符
fellow[0].income == (*him).income
必须要使用圆括号，因为 . 运算符比 * 运算符的优先级高
如果 him 是指向 guy 类型结构 barney 的指针，下面的关系恒成立
barney.income == (*him).income == him->income // 假设 him == &barney
