在编写程序时，简单的变量类型已经不能满足程序中各种复杂数据的需求，因此c语言还提供了构造类型的数据，构造数据是有基本数据按照一定的规则组成的。
目录
结构体类型的概念
结构体变量的定义
结构体变量的初始化
结构体变量的引用
结构体数组
结构体指针
结构体传参
共用体
枚举类型
结构体内存对齐
为什么存在内存对齐？
结构体大小计算
修改默认对齐数求大小
嵌套结构体计算大小
结构体类型的概念
结构体是一种由若干个成员组成的构造类型，成员可以是几种基本类型数据，也可以是另外的构造类型。既然结构体是一个构造类型，就需要先对其进行构造，我们称这个操作为声明一个结构体。
例如，一个学生包含学号，性别，分数等特点，一个老师有性别，年龄，教学科目等类别。
这两种类型就不能用普通的变量类型来表示，我们就可以自己定义一个结构体。
声明结构体的关键字为struct，一般形式如下
struct 结构体名
{
成员列表；
};
大括号后边的分号切记不能忘记。
结构体名可以为teacher student,等等等等都可以，大括号里面的就是你所创建出的结构体具有哪些特征等。当然也可以放另一个结构体变量，我们后边会谈到。
声明上边的两种类型的结构体
如下
struct student
{
char name[10];//名字
int grade;//分数
int num;//学号
char sex;//性别
};
struct teacher
{
char name[10];
int age;
char sex;
char project[10];//任课科目
};结构体变量的定义
前边已经介绍了如何声明一个结构体，如何使用构造的结构体才是我们的真正目的。
定义结构体变量的方法有两种
我们已经声明了student结构体，可以在程序中直接用定义一个小明，也可以再定义一个小红，要注意，声明一个结构体是创建一种新的类型名，要用新的类型名再定义变量，student的类型名为struct student。
定义如下：
struct student xiaoming；
struct student xiaohong；
结构体也可以使用typedef重命名，可以使定义变量时更加便捷。
例如
typedef struct student
{
char name[10];//名字
int grade;//分数
int num;//学号
char sex;//性别
}Student;定义该结构体类型名为Student，再次定义一个新的变量就可以这样写
Student xiaogang;
是不是有很方便。
这种定义的方式可以写在函数内，也可以写在函数外部，写在函数外部就是全局变量。
这个时候就要说一说另一种定义变量的方式
struct student
{
char name[10];//名字
int grade;//分数
int num;//学号
char sex;//性别
}xiaoming,xiaogang;可以看到，这种形式将定义的变量直接放在声明结构体的末尾处，需要注意的是要放在分号的前边且可以定义多个变量。
但是，这种定义方式不好的缺点是，如果这个结构体在头文件中存放，那么定义出的结构体变量都是全局变量，全局变量使用起来很危险，所以这种定义方式我们不推荐。
结构体变量的初始化
上边说过，这种直接在声明后边定义的方式并不推荐，但还是要知道，可以在声明后定义时就初始化，有点绕？
声明就是一栋房子的建造图纸，可以用这个图纸来造很多相似的房子，定义就是用图纸盖一栋房子，我们有了房子就可以在房子里放东西，布置布置，初始化就是粉刷房子，为房子内的房间装饰。
是不是懂啦
上边说边声明边定义边初始化，就是下边这样
struct student
{
char name[10];//名字
int grade;//分数
int num;//学号
char sex[20];//性别
}xiaoming = { "xiaoming",98,666,"男" };
定义的变量后边使用等号，然后将初始化的值放在大括号里，每一个数据要和结构体成员列表的顺序一样。
还有一种发方法就是定义初始化和声明分离
typedef struct student
{
char name[10];//名字
int grade;//分数
int num;//学号
char sex;//性别
}Student;
int main()
{
Student xiaohong = { "xiaohong",99,6666,"女" };
return 0;
}
是不是很简单就可以实现？
结构体变量的引用
如果我们想要修改结构体成员变量的值呢？
printf("%s %d %d %s",xiaohong); ??????XXXXXX错误的哦
如果想要对结构体成员进行操作，我们就要拿出这个结构体中的变量，这个过程就叫做引用。
一般形式如下
结构体变量名.成员名
例如，小红的分数更改为100
更改完成之后直接打印验证
如果是结构体里面套着结构体呢？
给Student加上birthday结构体储存其生日，如果记错了，如何修改其生日呢？
让Student结构体里有一个Birthday结构体变量，然后修改
直接公布答案
typedef struct birthday
{
int month;
int day;
}Birthday;
typedef struct student
{
char name[15];//名字
int grade;//分数
int num;//学号
char sex[10];//性别
Birthday data;
}Student;
int main()
{
Student xiaohong = { "xiaohong",99,6666,"女" ,{4,4} };
xiaohong.data.day = 3;
xiaohong.data.month = 3;
xiaohong.grade = 100;
printf("%d ", xiaohong.grade);
printf("%d %d\n", xiaohong.data.day,xiaohong.data.month);
return 0;
}看见没看见没，如果是结构体里面有结构体变量，那么初始化内部的结构体变量的成员也要用大括号括起来。
结构体成员变量可以像普通变量一样进行各种运算。
结构体数组
我们已经知道了数组可以装好多种类型，当然结构体数组也不奇怪。结构体变量可以放好多组数据，结构体数组可以存放好几组结构体变量，就像一个小孩（结构体变量）有很多特征（结构体内部成员变量），一个班级（结构体数组）可以装好多小孩一样。
我们可以定义一个结构体数组
代码如下
typedef struct student
{
char name[15];//名字
int grade;//分数
int num;//学号
char sex[10];//性别
Birthday data;
}Student;
int main()
{
Student stu[3] = { {"dingding",66,22222,"女",{6,6}},{"shuaishuai",77,22223,"男",{6,6}} ,{"dengquan",88,22224,"男",{6,6}} };
for (int i = 0; i < 3; i++)
{
printf("%s %d %d %s %d %d", stu[i].name, stu[i].grade, stu[i].num, stu[i].sex, stu[i].data.month, stu[i].data.day);
printf("\n");
}
return 0;
}运行后代码如下
因为shuaishuai的名字长度为10，创建10个字符的数组，就无法存储结束标志\0，所以这里将名字的数组扩大为15，如果大家用汉字会报错的话，采取以下步骤
右击
高级->字符集->无
就可以正常使用汉字了，一个汉字两个字节。
回归上边的操作，要记住的是，初始化结构体数组，每个结构体变量初始化内容要用大括号扩住，访问还是用.引用操作符，如果结构体套结构体的话，就多引用一次即可。
结构体指针
指针可以指向整形，浮点型，甚至还可以指向他自己，变成二级指针，一个指向变量的指针表示该变量的起始地址，那么结构体指针就指向结构体变量的起始地址。
既然指针指向结构体变量的地址，那么我们就可以通过结构体指针来访问结构体内的成员。
定义结构体指针的格式如下：
结构体类型 *指针名；
例如，定义一个Student结构类型的指针如下
Student *pstu;
重点来啦，使用结构体指针访问结构体成员有两种方法
第一种就是解引用在用.引用操作符进行引用
typedef struct birthday
{
int month;
int day;
}Birthday;
typedef struct student
{
char name[15];//名字
int grade;//分数
int num;//学号
char sex[10];//性别
Birthday data;
}Student;
int main()
{
Student xiaohong = { "xiaohong",99,6666,"女" ,{4,4} };
Student* ptr = &xiaohong;
(*ptr).grade = 100;
printf("%d ", xiaohong.grade);
return 0;
}
这里一定要注意，解引用结构体指针一定要用括号括住，这是因为.引用操作符的优先级比*解引用操作符优先级高，我们要的是先解引用结构体指针，再引用其成员变量。
还有一种方式
使用指向操作符引用结构体成员
代码如下（结构体声明部分省略）
int main()
{
Student xiaohong = { "xiaohong",99,6666,"女" ,{4,4} };
Student* ptr = &xiaohong;
//(*ptr).grade = 100;
ptr->grade = 101;
printf("%d ", xiaohong.grade);
return 0;
}
运行结果如图
结构体传参
结构体变量可以作为函数的参数，但是要记住哦，传参传过去的都是形参，形参的改变不影响实参，所以我们传结构体变量就只能访问其内部成员变量的值，想要在该函数里修改结构体变量，就要传结构体指针过去。
传参访问，要注意接收函数的参数类型要相同
typedef struct birthday
{
int month;
int day;
}Birthday;
typedef struct student
{
char name[15];//名字
int grade;//分数
int num;//学号
char sex[10];//性别
Birthday data;
}Student;
void PrintStu(Student A)//这里给什么名字都可以，形参的名字
{
printf("%s %d %d %s %d %d", A.name, A.grade, A.num, A.sex, A.data.month, A.data.day);
}
int main()
{
Student xiaohong = { "xiaohong",99,6666,"女" ,{4,4} };
Student* ptr = &xiaohong;
//(*ptr).grade = 100;
PrintStu(xiaohong);
return 0;
}我们可以访问，打印结构体成员的信息。
我们尝试着修改一个变量
void PrintStu(Student A)//这里给什么名字都可以，形参的名字
{
printf("%s %d %d %s %d %d", A.name, A.grade, A.num, A.sex, A.data.month, A.data.day);
A.grade = 100;
}将分数改为100，在主函数再打印一次。
可以发现两次打印的数据没有变化，形参改变不影响实参。
传入结构体指针
再次运行
共用体
共用体和结构体很相似，只不过关键字由struct变为了union，区别在于：结构体为所有成员变量开独立的内存，而共用体定义了一块能容纳所有数据成员共享的内存。这也就确定了
声明形式如下
union 共用体名
{
成员列表；
}；
定义一个结构体
union Data
{
int i;char c;
double d;
}
他和结构体的引用和初始化一模一样，不再赘述。
有必要谈一谈的是共用体类型的数据特点
1，同一段内存可以用来存放几种不同类型的成员，但是每次只能够存放他们其中的一种，而不能同时存放所有的类型，这也代表在共用体中，同事只能有一个成员起作用，其他成员不起作用。
2，共用体初始化后起作用的成员是最后一次存放的成员，再存入一个新的值后，前边的所有成员就失去作用，如果要调用其中的某个成员，那么该成员就起作用，另外的成员不起作用。
3，共用体变量的地址和他各个成员的地址相同。
4，因为共用体的地址和各成员地址一样，不能对共用体变量名赋值，也不可以企图引用变量来得到一个值，违反了程序的确定性。
枚举类型
利用关键字enum可以声明枚举类型，这也是一种数据类型，使用枚举类型可以定义枚举类型变量，几个枚举变量为一组同类型的标识符，每个标识符都对应一个整数值，称为枚举常量。
定义一个枚举类型变量
enum Colors{
RED,
GREEN,
BLUE
};
在括号中，第一个标识符就对应1，第二个对应2，以此类推。
每个标识符都必须是独特嘚！
也可以为某个标识符设置其对应得整形值，后边的标识符依次加一。
例如：
enum Colors{
RED=1,
GREEN,
BLUE
};
此时GREEN就是2，BLUE就是3。
枚举类型通常和switch配合使用，case后边只能是整形数字，使用枚举就解决了这一问题，让代码功能更加清晰。
代码如下
typedef enum Colors
{
RED = 1,
BLUE,
GREEN
}color;
int main()
{
int icolor;
scanf("%d", &icolor);
switch (icolor)
{
case RED:
printf("RED\n");
break;
case BLUE:
printf("BLUE\n");
break;
case GREEN:
printf("GREEN\n");
break;
default:
break;
}
return 0;
}结构体内存对齐
结构体内存对齐是一个十分热门的考题，这里一定要正确记住内存对齐的规则。
结构体的的大小不是里面变量类型的大小累加得到的，而是通过默认的结构体对齐规则，再通过计算得到的。
要记住的是
1，第一个成员在偏移量为0处。
2，第一个后边的成员对齐到变量大小与最小对齐数中小的那个的整数倍处。
对齐数：编译器默认的一个最小对齐数和该成员变量大小的较小值
VS：最小对齐数默认为8
可以用#pragma pack(4)更改默认对齐数
Linux：没有默认对齐数，对齐数就是成员函数本身。
3，结构体总大小为最大对齐数的整数倍
4，如果结构体中嵌套了结构体，嵌套的结构体对齐到自己最大对齐数的整数倍处，结构体的整体大小就是所有最大对齐数的整数倍（包含嵌套结构体的对齐数）。
为什么存在内存对齐？
1，平台原因
不是所有的硬件都能访问任一地址上的任意数据，某些平台只能在某些地址处取出某些特定类型的数据，不然会报错，为了互容，出现了内存对齐。
2，性能原因
数据的结构应该尽可能在自然边界上对齐，原因在于为了访问没有对齐的内存，处理器需要两次内存访问，而对齐的内存只需要访问一次即可。也就是用空间来换时间。
结构体大小计算
看下边两种结构体
struct S1
{
char c1;
int i;
char c2;
};
struct S2
{
char c1;
char c2;
int i;
};
int main()
{
printf("%d ", sizeof(struct S1));
printf("%d ", sizeof(struct S2));
return 0;
}打印结果
一定要记住，内存对齐是从0开始的，所以所占内存是对齐到的位置加1。
第一个结构体：
不信的话我们可以通过offsetof函数来查看结构体成员，不要忘记包含头文件stddef.h
代码如下
#include <stddef.h>
struct S1
{
char c1;
int i;
char c2;
};
struct S2
{
char c1;
char c2;
int i;
};
int main()
{
printf("%d\n", offsetof(struct S1, c1));
printf("%d\n", offsetof(struct S1, i));
printf("%d\n", offsetof(struct S1, c2));
printf("%d ", sizeof(struct S1));
printf("%d ", sizeof(struct S2));
return 0;
}运行结果如图所示
验证了我们的猜想。
第二个结构体：
可以发现，结构体内部装有相同的数据，只不过排布顺序不一样，就产生了4个字节的浪费，这只不过是两个小小的结构体，才四个字节，然而万一是一个链表呢？成千上万个节点，每个节点浪费4个字节，那就开销很大了，所以我们也要注意结构体的排布问题。
修改默认对齐数求大小
#pragma pack(4)
//更改默认对齐数
struct A
{
char c1;
int i;
char c2;
double d;
};这个结构体的大小是多少呢？
要注意的是，默认对齐数已经被更改了，double类型的数据不会对齐到8的倍数，而是修改后的VS提供的默认对齐数。
在VS里运行一下看一看
没有问题！如果没有修改默认对齐数的话，就会对齐至16的位置，从16往后走8个字节，23-16+1=8（包含16，所以停在23的位置）,23-0+1=24（从零开始，故-0+1），刚好是8的倍数,将更改默认对齐数的代码注释再次运行
结果如我们所料。
嵌套结构体计算大小
再建造一个结构体，嵌套后观察大小，上边的结构体大小没有修改默认对齐数的话大小为24。
代码如下
struct A
{
char c1;
int i;
char c2;
double d;
};
struct B
{
char c;
struct A a;
int k;
};
int main()
{
printf("%d ", sizeof(struct A));
printf("%d ", sizeof(struct B));
return 0;
}结果是多少呢？
我们来推导一下：
在VS里跑一下验证结果是否正确
结构体的内存对齐规则和大小计算你学费了吗？
联合体的大小计算
union Un
{
short s[7];
int n;
};
int main()
{
printf("%d ", sizeof(union Un));
return 0;
}联合体只会开辟最大的一个成员的内存，第一个成员的内存为14，int的内存为4，所以选择第一个成员，默认对齐数为8，最后的结果为8的倍数，故最终联合体的大小为16。
运行代码后结果如下
ok.今天的文章就结束啦，欢迎大家一起交流进步！
