>C 结构体类型创建
C 数组允许定义可存储相同类型数据项的变量，结构是 C 编程中另一种用户自定义的可用的数据类型，它允许您存储不同类型的数据项。
结构用于表示一条记录，假设您想要跟踪图书馆中书本的动态，您可能需要跟踪每本书的下列属性：
Title
Author
Subject
Book ID
定义结构
为了定义结构，您必须使用
struct
语句。struct 语句定义了一个包含多个成员的新的数据类型，struct 语句的格式如下：
struct
tag
{
member
-
list
member
-
list
member
-
list
...
}
variable
-
list
;
tag
是结构体标签。
member-list
是标准的变量定义，比如 int i; 或者 float f，或者其他有效的变量定义。
variable-list
结构变量，定义在结构的末尾，最后一个分号之前，您可以指定一个或多个结构变量。下面是声明 Book 结构的方式：
struct
Books
{
char
title
[
50
]
;
char
author
[
50
]
;
char
subject
[
100
]
;
int
book_id
;
}
book
;
在一般情况下，
tag、member-list、variable-list
这 3 部分至少要出现 2 个。以下为实例：
//此声明声明了拥有3个成员的结构体，分别为整型的a，字符型的b和双精度的c
//同时又声明了结构体变量s1
//这个结构体并没有标明其标签
struct {
int a;
char b;
double c;
} s1;
//此声明声明了拥有3个成员的结构体，分别为整型的a，字符型的b和双精度的c
//结构体的标签被命名为SIMPLE,没有声明变量
struct SIMPLE {
int a;
char b;
double c;
};
//用SIMPLE标签的结构体，另外声明了变量t1、t2、t3
struct SIMPLE t1, t2[20], *t3;
//也可以用typedef创建新类型
typedef struct {
int a;
char b;
double c;
} Simple2;
//现在可以用Simple2作为类型声明新的结构体变量
Simple2 u1, u2[20], *u3;
在上面的声明中，第一个和第二声明被编译器当作两个完全不同的类型，即使他们的成员列表是一样的，如果令 t3=&s1，则是非法的。
结构体的成员可以包含其他结构体，也可以包含指向自己结构体类型的指针，而通常这种指针的应用是为了实现一些更高级的数据结构如链表和树等。
如果两个结构体互相包含，则需要对其中一个结构体进行不完整声明，如下所示：
//此结构体的声明包含了其他的结构体
struct COMPLEX {
char string[100];
struct SIMPLE a;
};
//此结构体的声明包含了指向自己类型的指针
struct NODE {
char string[100];
struct NODE *next_node;
};
struct B; //对结构体B进行不完整声明
//结构体A中包含指向结构体B的指针
struct A {
struct B *partner; //other members;
};
//结构体B中包含指向结构体A的指针，在A声明完后，B也随之进行声明 struct B { struct A *partner; //other members; };
访问结构成员
-
结构体变量访问成员。结构体变量的成员是通过点操作符（.）访问的。点操作符接受两个操作数。
例如：
struct Stu {
char name[20];
int age;
};
struct Stu s;//定义结构体变量
我们看到 s 有成员 name 和 age
那么如何访问 s 的成员呢 ？
struct S s;
strcpy(s.name, "zhangsan");
//使用 . 访问 name 成员
s.age = 20;
//使用 . 访问 age 成员
-
结构体访问指向变量的成员。 有时候我们得到的不是一个结构体变量，而是一个指向结构体的指针。
那么如何访问成员？如下：
struct S {
char name[20];
int age;
}s;
void print(struct S* PS)
{
printf("name = %s age = %d\n",
(*ps).name, (*ps).age
);
printf("name = %s age = %d\n",
ps -> name, ps -> age);
}
>结构体初始化
结构体的初始化是指在定义结构体变量的同时，对结构体变量中成员进行赋初值。
结构体的初始化的一般格式：
struct 结构体类型名 结构体变量 = { 初始化列表 }
struct Point {
int x;
int y;
}p1;
//声明类型的同时定义变量p1
struct Point p2;//定义结构体变量p2
struct Point p3 = { x, y }
//初始化：定义变量的同时赋初值
struct Stu {
char name[15];
int age;
};
struct Stu s = { "zhangsna", 20 };
//初始化
struct Node {
int data;
struct Point p;
struct Node* next;
}n1 = { 10, { 4, 5 }, NULL };
//结构体嵌套初始化
struct Node n2 = { 20, { 5, 6 }, NULL };
//结构体嵌套初始化
>结构体内存对齐
为什么要内存对齐？
主要有两方面原因：
1.平台原因（移植原因）
不是所有的硬件平台都能访问任意地址上的任意数据的；
某些硬件平台只能在某些地址处取某些特定类型的数据，否则抛出硬件异常。
2.性能原因
数据结构（尤其是栈）应该尽可能地在自然边界上对齐。
原因在于，为了访问未对齐的内存 ，处理器需要作两次内存访问；而未对齐的内存仅需要一次访问。
对齐规则：
1.第一个成员在与结构体变量
偏移量为0的地址处。（第一个成员有对齐数，但不需要对齐，默认对齐）
2.其他成员变量要对齐到
某个数字（对齐数）的整数倍的地址处。对齐数 = 编译器默认的一个对齐数与该成员大小的较小值。 VS中默认的值为8，Lunix中的默认值为4.
3.结构体总大小为
最大对齐数的（每个成员都有一个对齐数）
整数倍。
4.如果嵌套了结构体的情况，嵌套的结构体对齐到自己的最大对齐数的整数倍处，结构体的整体大小就是所有对齐数（含嵌套体的对齐数）的整数倍。
练习：
//本次调试环境为VS，因此VS默认的对齐数为 8
//练习1
struct S1 {
char c1;
//1 -> 1 + 3 = 4
int i;
//4 -> 4 + 4 = 8
char c2;
//1 -> 8 + 1 = 9
};//
结构体总大小为
最大对齐数
的（每个成员都有一个对齐数）
整数倍
。9 + 4 = 12
printf("%d\n", sizeof(struct S1) );//12
//练习2
struct S2 {
char c1;
//1 -> 1
char c2;
//1 -> 1 + 1 + 2 = 4
int i;
//4 -> 4 + 4 = 8
};
//8 结构体最大对齐数为 4
printf("%d\n", sizeof(struct S2) );
//8
//练习3
struct S3 {
doubel d;//8 -> 8
char c;//1 -> 8 + 1 + 3 = 12
int i;//4 -> 12 + 4 = 16
};//16 结构体最大对齐数为 8
printf("%d\n", sizeof(struct S3) );
//16
//练习4-结构体嵌套问题
struct S4 {
char c1;//1 ->1 + 7 = 8 ( s3的最大对齐数为8 )
struct S3 s3;
//16 -> 8 + 16 = 24
double d;
//8 -> 24 + 8 = 32
};
//32
printf("%d\n", sizeof(struct S4) );
//32
总体来说：
结构体的内存对齐是拿空间换取时间的做法。
>位段，位段计算机大小。
什么是位段？
位段的声明和结构是类似的，有两个不同：
1.位段的成员类型必须是
int、unsigned int 或 signed int 。
2.位段的成员名后面有一个冒号和一个数字。
比如：
struct A {
int _a:2;
//先开辟4字节空间（32位），变量 _a 只占2个比特位，还剩30个比特位
int _b:5;
//_b 占了5个bit，够用，还剩25bit
int _c:10;
//_c 占了10bit,够用，还剩15bit
int _d:20;
//_d 占了20bit，不够用，开辟4字节空间
};
//总共开辟8字节空间
A就是一个位段类型。
那么位段A的大小是多少？
printf("%d\n", sizof(struct A) );
//8字节
位段的内存分配：
1.位段的成员可以是
int、unsigned int 、 signed int 或者是
char 类型。
2.位段的空间上是按需要以4字节（
int ）或者1个字节（
char ）的方式来开辟的。
3.位段涉及很多不确定因素，位段是不跨平台的，注重可移植的程序应该比曼使用位段。
>枚举+联合（共用体）。
枚举，顾名思义就是：一一列举。把可能的值一一列举。
比如现实生活中：
一周的星期一到星期日是有限的7天，可以一一列举。
性别有：男、女、保密，也可以一一列举。
月份有12个月，也可以一一列举。
颜色也一样。
enum Day
{
//星期
Mon,
Tues,
Wed,
Thur,
Fri,
Sat,
Sun
};
enum Sex {
//性别
MALE,
FEMALE,
SECERT
};
{}中的内容是枚举类型的可能取值，也叫枚举常量。这些可能取值都是有值得，默认从0开始，一次递增1，当然在定义的时候也可以赋初值。
联合
联合类型的定义：
联合也是一种特殊的自定义类型。
这种类型定义的变量也包含一系列的成员，特征是这些成员共用同一块空间（所有联合体也叫共用体）。
所有的成员变量的地址都是联合体第一个字节的地址。
联合的特点：
联合的成员是共用同一块内存空间的，这样一个联合变量的大小，至少是最大成员的大小。
union Un {
int i;
char c;
};
union Un un;
//下面的输出结果一样
printf("%d\n", &(un.i));
printf("%d\n", &(un.c));
//下面输出结果是什么？
un.i = 0x11223344;
un.c = 0x55;
printf("%x\n", un.i);//0x11223355
判断当前计算机的大小端存储：
给i赋值1，输出 c 。c 为1，小端；c 为 0，大端。
联合体大小的计算：
-
联合的大小至少是最大成员的大小。
-
当最大成员大小不是最大对齐数的整数倍的时候，就要对齐到最大对齐数的整数倍。
联合体和结构体的巧妙使用：
//将long类型的IP地址，转为点分十进制的表示形式
union ip_addr {
unsigned long addr;
struct {
unsigned char c1;
unsigned char c2;
unsigned char c3;
unsigned char c4;
}ip;
};
union ip_addr my_ip;
my_ip.addr = 176238749;
printf("%d.%d.%d.%d\n", my_ip.c4,
my_ip.c3, my_ip.c2, my_ip.c1);
