结构是一个或多个变量的集合，这些变量可能为不同的类型，为了处理的方便而将这些变量组织在一个名字之下。
比如，将坐标系中的x 坐标和y 坐标组织在一起作为一个“点”结构，或者将姓名、性别、年龄等信息组织在一起作为一个描述“人”的结构。
struct {
int x; /* x坐标 */
int y; /* y坐标 */
};
struct {
char *name;
int sex;
int age;
};
上面代码是结构本身的声明。结构是一种数据类型，类似int 、double 之类的东西，声明一个int 类型的变量如下：
int a;
类似的，声明一个结构类型的变量格式如下：
struct {
int x;
int y;
} a;
也可以给结构起个名字，或者叫标记，如下：
struct point { /* point 是结构的标记 */
int x;
int y;
};
这样就可以用point 代替大括号里的内容，声明结构类型的变量就可以写作：
struct point a;
下面代码是错误的：
main(){
struct point p;
p.x = 1;
p.y = 2;
}
struct point {
int x;
int y;
};
因为代码的下面部分是结构的声明，而main 函数中要使用这个结构，所以应该把结构的声明放在使用之前，正确代码如下：
struct point {
int x;
int y;
};
main(){
struct point p;
p.x = 1;
p.y = 2;
}
这与int 等基本类型可以随意使用不同，因为结构是自定义类型。
上面这段正确代码编译后的汇编代码如下：
.file "struct.c"
.intel_syntax
.def ___main; .scl 2; .type 32; .endef
.text
.globl _main
.def _main; .scl 2; .type 32; .endef
_main:
push ebp
mov ebp, esp
sub esp, 24
and esp, -16
mov eax, 0
add eax, 15
add eax, 15
shr eax, 4
sal eax, 4
mov DWORD PTR [ebp-12], eax
mov eax, DWORD PTR [ebp-12]
call __alloca
call ___main
mov DWORD PTR [ebp-8], 1
mov DWORD PTR [ebp-4], 2
leave
ret
这段代码中并没有能体现原代码中声明的那个点结构的代码，也就是代码：
struct point {
int x;
int y;
};
在编译后就没了。原代码与下面代码：
main(){
int x = 1;
int y = 2;
}
在编译后并无任何不同。这与int 等基础类型也很相似，定义或声明一个int 类型的变量，在编译后的汇编代码中也不存在“int ”这个东西，而是在给变量分配内存空间时会按照int 类型的长度分配4个内存单元（具体长度与机器有关）。若是定义了一个char 类型的变量，那么在分配内存时就会为变量分配1个内存单元。
所以，必然有一个地方存储着有关“结构”的描述内容，编译器才能根据结构描述直接为结构类型的变量分配内存空间，而“结构”也才能不在编译后的代码中存在。相关内容可以参考C语言的“符号表和类型系统”。
再来看一个例子：
struct person {
char *name;
char sex;
int age;
};
main(){
struct person p;
p.name = "YCY";
p.sex = 1;
p.age = 21;
printf("%d", sizeof(p));
}
编译后的汇编代码：
.section .rdata,"dr"
LC0:
.ascii "YCY\0"
LC1:
.ascii "%d\0"
.text
_main:
mov DWORD PTR [ebp-24], OFFSET FLAT:LC0
mov BYTE PTR [ebp-20], 1
mov DWORD PTR [ebp-16], 21
mov DWORD PTR [esp+4], 12
mov DWORD PTR [esp], OFFSET FLAT:LC1
call _printf
leave
ret
代码中存储char 类型的值用了4 个字节，而char 指针类型则是用4个字节存储的字符数组首地址。可见，编译后的代码会根据结构声明为结构成员分配内存，同时还会考虑内存对齐的问题。所以结构的长度并不一定等于结构内每个数据类型的长度之和。
本章剩余内容有：
1.结构与函数
2.结构数组
3.自引用结构
4.类型定义
5.联合
6.位字段
下面分别举例进行说明。
1.结构与函数：
#include <stdio.h>
struct point { /* point 是结构的标记 */
int x;
int y;
};
struct point addpoint(struct point p1, struct point p2)
{
p1.x += p2.x;
p1.y += p2.y;
return p1;
}
main(){
struct point p1 = {1,2};
struct point p2 = {3,4};
addpoint(p1, p2);
}
上面例子中，函数的参数和返回值都是结构类型。编译后汇编代码：
.text
_addpoint:
push ebp
mov ebp, esp
mov eax, DWORD PTR [ebp+16]
add DWORD PTR [ebp+8], eax
mov edx, DWORD PTR [ebp+20]
lea eax, [ebp+12]
add DWORD PTR [eax], edx
mov eax, DWORD PTR [ebp+8]
mov edx, DWORD PTR [ebp+12]
pop ebp
ret
_main:
mov DWORD PTR [ebp-8], 1
mov DWORD PTR [ebp-4], 2
mov DWORD PTR [ebp-16], 3
mov DWORD PTR [ebp-12], 4
mov eax, DWORD PTR [ebp-16]
mov edx, DWORD PTR [ebp-12]
mov DWORD PTR [esp+8], eax
mov DWORD PTR [esp+12], edx
mov eax, DWORD PTR [ebp-8]
mov edx, DWORD PTR [ebp-4]
mov DWORD PTR [esp], eax
mov DWORD PTR [esp+4], edx
call _addpoint
leave
ret
可以看到，结构无论是作为参数还是返回值，结构成员的值都是直接存储在栈内存或者寄存器之中的，与一般变量并无不同。
2.结构数组：
struct key {
char *word;
int count;
} keytab[] = {
"auto", 0,
"break", 0,
"case", 0,
"char", 0,
"const", 0,
"continue", 0,
"default", 0,
"unsigned", 0,
"void", 0,
"volatile", 0,
"while", 0
};
main(){
int length = sizeof(keytab);
int i = 0;
for(; i<length; i++){
if(keytab[i].word=="char")
keytab[i].count++;
}
}
上述代码声明了key 结构的数组keytab，并进行了初始化。main 函数中遍历结构数组keytab，遇到关键字char 则将其数量加1。编译后汇编代码如下：
.section .rdata,"dr"
LC0:
.ascii "auto\0"
LC1:
.ascii "break\0"
LC2:
.ascii "case\0"
LC3:
.ascii "char\0"
LC4:
.ascii "const\0"
LC5:
.ascii "continue\0"
LC6:
.ascii "default\0"
LC7:
.ascii "unsigned\0"
LC8:
.ascii "void\0"
LC9:
.ascii "volatile\0"
LC10:
.ascii "while\0"
.globl _keytab
.data
.align 32
_keytab:
.long LC0
.long 0
.long LC1
.long 0
.long LC2
.long 0
.long LC3
.long 0
.long LC4
.long 0
.long LC5
.long 0
.long LC6
.long 0
.long LC7
.long 0
.long LC8
.long 0
.long LC9
.long 0
.long LC10
.long 0
.text
_main:
mov DWORD PTR [ebp-4], 88
mov DWORD PTR [ebp-8], 0
L2:
mov eax, DWORD PTR [ebp-8]
cmp eax, DWORD PTR [ebp-4]
jge L3
mov eax, DWORD PTR [ebp-8]
cmp DWORD PTR _keytab[0+eax*8], OFFSET FLAT:LC3
jne L4
mov eax, DWORD PTR [ebp-8]
inc DWORD PTR _keytab[4+eax*8]
L4:
lea eax, [ebp-8]
inc DWORD PTR [eax]
jmp L2
L3:
leave
ret
由此可见，结构数组与普通数组差别不大，只是把结构成员按普通数组成员的形式进行了展开而已。
3.自引用结构
struct tnode { /* the tree node: */
char *word; /* points to the text */
int count; /* number of occurrences */
struct tnode *left; /* left child */
struct tnode *right; /* right child */
};
main(){
struct tnode node1 = {"char",1,NULL,NULL};
struct tnode node2 = {"void",2,NULL,NULL};
struct tnode node3 = {"case",3,&node1,&node2};
}
上述代码中，node1和node2变量类似int x中的x变量，代表的是等号后面整个大括号里的内容，所以要用&取地址，而不像数组名可以直接赋值给指针类型的变量。
编译后的汇编代码如下：
LC0:
.ascii "char\0"
LC1:
.ascii "void\0"
LC2:
.ascii "case\0"
.text
_main:
mov DWORD PTR [ebp-24], OFFSET FLAT:LC0
mov DWORD PTR [ebp-20], 1
mov DWORD PTR [ebp-16], 0
mov DWORD PTR [ebp-12], 0
mov DWORD PTR [ebp-40], OFFSET FLAT:LC1
mov DWORD PTR [ebp-36], 2
mov DWORD PTR [ebp-32], 0
mov DWORD PTR [ebp-28], 0
mov DWORD PTR [ebp-56], OFFSET FLAT:LC2
mov DWORD PTR [ebp-52], 3
lea eax, [ebp-24]
mov DWORD PTR [ebp-48], eax
lea eax, [ebp-40]
mov DWORD PTR [ebp-44], eax
leave
ret
可见，自引用结构只是将（另一个）结构的地址作为值赋给了结构中指向本结构的指针变量。
4.类型定义
C 语言提供了一个称为 typedef 的功能，它用来建立新的数据类型名，例如，声明：
typedef int Length;
将 Length 定义为与 int 具有同等意义的名字。类型 Length 可用于类型声明、类型转换等，它和类型 int 完全相同，例如：
typedef int Length;
main(){
Length len1 = 10;
Length len2 = 20;
Length *lengths[] = {&len1, &len2};
}
类型定义同样在编译后的汇编代码中不存在。
5.联合
union number {
int ivalue;
float fvalue;
char *svalue;
};
联合声明形式和结构类似，只是把struct 关键字换成了union 。上面的联合声明表示，这个联合类型的变量可以存储为三种不同的类型值，但它们共用一个内存位置。例如：
union number {
int ivalue;
float fvalue;
char *svalue;
};
main(){
union number num;
num.ivalue = 1;
num.fvalue = 1.1;
num.svalue = "hello";
}
编译后的汇编代码：
.section .rdata,"dr"
LC1:
.ascii "hello\0"
.text
_main:
mov DWORD PTR [ebp-4], 1
mov eax, 0x3f8ccccd
mov DWORD PTR [ebp-4], eax
mov DWORD PTR [ebp-4], OFFSET FLAT:LC1
leave
ret
可见，无论给联合中的哪个成员变量赋值，结果都是存在同一个内存位置[ebp-4]中，访问时得到的是最后一次存入的内容。
6.位字段
类似汇编中的标志寄存器flag，用每一个二进制位来表示特定的信息。位字段（bit-field），或简称字段，是“字”中相邻位的集合。“字”（word）是单个的存储单元，它同具体的实现有关。
struct {
unsigned int is_keyword : 1;
unsigned int is_extern : 1;
unsigned int is_static : 1;
} flags;
main(){
flags.is_extern = 0;
flags.is_static = 1;
if (flags.is_extern == 0)
printf("hello, world");
if (flags.is_static == 1)
printf("hello, world");
}
编译后的汇编代码为：
.section .rdata,"dr"
LC0:
.ascii "hello, world\0"
.text
_main:
and BYTE PTR _flags, -3
or BYTE PTR _flags, 4
movzx eax, BYTE PTR _flags
shr al
movzx eax, al
and eax, 1
test eax, eax
jne L2
mov DWORD PTR [esp], OFFSET FLAT:LC0
call _printf
L2:
movzx eax, BYTE PTR _flags
shr al, 2
movzx eax, al
and eax, 1
cmp eax, 1
jne L3
mov DWORD PTR [esp], OFFSET FLAT:LC0
call _printf
L3:
leave
ret
.comm _flags, 16 # 4
这里存储位字段使用了16位，也即一个“字”的长度。
几个新汇编指令：
movax：数据传送指令mov的变体。无符号扩展，并传送。
test：将两个操作数进行逻辑与运算，并根据运算结果设置相关的标志位。test命令的两个操作数不会被改变。运算结果在设置过相关标记位后会被丢弃。test的其中一个功能是：若运算结果为0，则设置汇编标志寄存器的zf位为0。因此，代码：
test eax, eax
jne L2
可以测试寄存器eax 是否为0，当eax 所有位都为0时，两个eax 进行逻辑与运算结果才为0，并设置zf 为0，此时jne 指令不会跳转，其它情况都会跳转到L2。
好了，第六章的内容先学到这里。下一篇开始学习新的内容。
