文章详细介绍了C语言中的结构体，包括基础概念、声明、初始化、内存对齐以及自引用。接着讨论了位段的概念，其内存分配特点和跨平台问题。枚举部分讲解了其定义、使用和优点。最后，文章阐述了联合（共用体）的特性，大小计算以及在判断大小端存储中的应用。
1. 结构体
1.1结构的基础知识
结构是一些值的集合，这些值称为成员变量。结构的每个成员可以是不同类型的变量。
这里可以和数组进行对比，数组也使一些值的集合，每个成员是相同类型的
1.2结构体的声明
struct tag
{
member-list;//成员列表，可以是一个也可以是多个，不能没有
}variable-list;//变量列表什么是变量列表呢，我们来看下面的例子
struct stu
{
char name[20];
int age;
}s1,s2;//这里就是通过前面的类型创建的结构体变量，是全局变量
int main()
{
struct stu s3,s4;//这里是局部变量
return 0；
}但是除了上面这种写法外，我们还见过一种
typedef struct stu
{ //这样做是把这个结构体进行了重命名，叫S
char name[20];
int age;
}S;//这里就不再是变量了，而是结构体的类型
S s3,s4;//创建全局变量
int main()
{
S s1,s2;//这里我们就可以直接用重定义后的类型创建变量了，是局部变量。
return 0；
}//当然也可以先定义结构体类型再重命名
struct stu
{
char name[20];
int age;
};
typedef struct stu S;//这样做也是把这个结构体进行了重命名，叫S
S s3,s4;//创建全局变量
int main()
{
S s1,s2;
return 0；
}当然也可以将结构体的声明放在main函数里面
//外面就不能创建此类型的结构体变量了
int main()
{
struct stu
{
char name[20];
int age;
}stu;//只要是在main函数内部创建的变量都是局部变量
return 0;
}1.3特殊的声明
在声明结构的时候，可以不完全的声明。
例如
//匿名结构体类型
struct
{
char name[20];
int age;
}stu;//只能在这里创建变量，其他地方无法创建，因为他没有名字，
int main()
{
//在main函数里无法再进行创建
return 0;
}问题出现了
struct
{
char name[20];
int age;
}stu;
struct
{
char name[20];
int age;
}*p;
int main()
{
p = &stu;//请问这样行不行？
return 0;
}此时我们如果进行编译，编译器会报警告，类型不兼容，编译器不会因为你俩的成员是一样的就认为你俩的类型是一样的，编译器会把两个声明当成完全不同的两个类型，这种代码是非法的。
1.4结构体的自引用
什么是自引用呢？
接下来我们会引入链表这一概念
链表：是一种数据结构
数据结构：是数据在内存中存储的结构
例如存储1，2，3，4，5
每个节点都要进行 存放数、找下一个节点 的操作，这时我们就想，是否可以把每个节点设置成一个结构体
//那有人就写出了这样的代码
struct Node
{
int data;
struct Node next;//这里包含下一个节点
};这样写行不行呢？
那当然是不行的
你有没有想过这个结构体的大小？
我们知道int是4字节，struct Node next还得包括一个同类型结构体，这个同类型结构体里面又有一个4字节的int，又有一个同类型的结构体……这样我们就会发现这个节点就无限大了，所以结构体里包含一个同类型的结构体是坚决不行的
但是我们可以存放一个指向下一个节点的指针，通过指针找到接下来的节点，并且节点的大小也是确定的：4字节的int，4/8字节的指针
所以呢我们应该这样写
struct Node
{
int data;
struct Node* next;//这里存放同类型的下一个节点的地址
};这种设计就是结构体的自引用
能不能重命名呢？
typedef struct Node
{
int data;
Node* next;
}Node;
//这样写代码，行不行？当然是不行的，Node是在结构体声明之后再重命名的，怎么能在声明的时候就直接使用Node呢
正确的应该是这么写
typedef struct Node
{
int data;
struct Node* next;
}Node;1.5结构体变量的定义和初始化
struct Point
{
int x;
int y;
}p1; //声明类型的同时定义变量p1
struct Point p2; //定义结构体变量p2
//初始化：定义变量的同时赋初值。
struct Point p3 = { 0, 0 };
struct Stu //类型声明
{
char name[15];//名字
int age; //年龄
float score;
struct Point P;
};
struct Stu s = { "zhangsan", 20, 99.5, {1, 2} };//初始化//顺序
struct Node
{
int data;
struct Point p;
struct Node* next;
}n1 = { 10, {4, 5}, NULL }; //结构体嵌套初始化
struct Node n2 = { 20, {5, 6}, NULL };//结构体嵌套初始化
int main()
{
struct Stu s2 = { .score = 65.3, .age = 15, .name = "lisi", .P.x = 5, .P.y = 6 };//乱序
printf("%s %d %f %d %d", s.name, s.age, s.score, s.P.x, s.P.y);
}1.6结构体内存对齐
计算结构体的大小
我们来看下面两个例子
struct S1
{
char c1;
int i;
char c2;
};
struct S2
{
char c1;
char c2;
int i;
};
int main()
{
printf("%d\n", sizeof(struct S1));
printf("%d\n", sizeof(struct S2));
return 0;
}或许有人会想：char c1:1字节，int i：4字节，char c2：1字节 总共是6字节。
但事实并非如此，这段代码的输出结果是：12 8
这里有两个疑问
1.这两个结构体成员一模一样，只是调整了顺序，为什么大小会发生不同呢？
2.总共六个字节就足够了，为什么一个是12，一个是8呢？
这就涉及到了结构体的内存对齐
首先得掌握结构体的对齐规则：
1.第一个成员在与结构体变量偏移量为0的地址处。
2.其他成员变量要对齐到每个数字的整数倍的地址处。
对齐数=编译器默认的一个对齐数 与 该成员大小的较小值。
（ vs中的默认的值为8，linux gcc没有默认对齐数）
3.结构体总大小为最大对齐数（每个成员变量都有一个对齐数）的整数倍。
4.如果嵌套了结构体的情况，嵌套结构体对齐到自己的最大对齐数的整数倍处，结构体的整体大小就是所有最大对齐数（含嵌套结构体的对齐数）的整数倍。
举个例子
struct S1
{
char c1;
int i;
char c2;
};这个大小为什么是12呢
1.首先 c1放到0偏移量处，char类型只占1字节
2.其次i大小为4字节，默认对齐数是8，对齐数取其较小值4，i要对齐到4的整数倍的地址处，也就是偏移量为4的地址处，占4字节。
3.c2大小为1，默认对齐数是8，对齐数取其较小值1，c2要对齐到1的整数倍的地址处，任何数字都是1的倍数，对齐到偏移量为8的地址处，占1字节。
4.目前结构体大小为9，这个结构体的最大对齐数是4，总大小应是4的倍数，所以总大小是12.
那些空着的地方是浪费的
如何证明偏移量是正确的呢呢？
有个函数叫offsetof，可以求出偏移量：
//这里需要引头文件
#include <stddef.h>
int main()
{
printf("%d\n", offsetof(struct S1, c1));
printf("%d\n", offsetof(struct S1, i));
printf("%d\n", offsetof(struct S1, c2));
return 0;
}求出的分别是0， 4， 8 与我们上方求出的一致。
那我们来多做几个练习
struct S2
{
char c1;
char c2;
int i;
};
printf("%d\n", sizeof(struct S2));struct S3
{
double d;
char c;
int i;
};
printf("%d\n", sizeof(struct S3));struct S4
{
char c1;
struct S3 s3;
double d;
};
printf("%d\n", sizeof(struct S4));struct S5
{
char c1;
char c2[3];
int i[2];
double d;
};
为什么存在内存对齐？
1.平台原因（移植原因）
不是所有的硬件平台都能访问任意地址上的任意数据的；某些硬件平台只能在某些地址处取某些特
定类型的数据，否则抛出硬件异常。
2.性能原因
数据结构(尤其是栈)应该尽可能地在自然边界上对齐。
原因在于，为了访问未对齐的内存，处理器需要作两次内存访问；而对齐的内存访问仅需要一次访问。
举个例子
struct S
{
char c;
int i;
};
假如要访问 i，如果从对其边界开始读取数据，如果我们的数据总线是32位，那一次读取数据读32个比特位，也就是4个字节，没有对齐的话要访问两次，对齐的话只访问一次。
总的来说：
结构体的内存对齐是拿空间来换取时间的做法。
那在设计结构体的时候，我们既要满足对齐，又要节省空间，如何做到：
让占用空间小的成员尽量集中在一起。（参考结构体S1，S2）
1.7修改默认对齐数
使用#pragma 这个预处理指令以改变我们的默认对齐数。
#pragma pack(8)//设置默认对齐数为8
struct S1
{
char c1;
int i;
char c2;
};
#pragma pack()//取消设置的默认对齐数，还原为默认
#pragma pack(1)//设置默认对齐数为1
struct S2
{
char c1;
int i;
char c2;
};
#pragma pack()//取消设置的默认对齐数，还原为默认
int main()
{
//输出的结果是什么？
printf("%d\n", sizeof(struct S1));//12
printf("%d\n", sizeof(struct S2));//6
return 0;
}结构体的内存对齐本来就是拿空间来换取时间的做法，所以不是默认对齐数越小越好。
1.8 结构体传参
struct S
{
int data[1000];
int num;
};
struct S s = { {1,2,3,4}, 1000 };
//结构体传参
void print1(struct S s)
{
printf("%d\n", s.num);
}
//结构体地址传参
void print2(struct S* ps)
{
printf("%d\n", ps->num);
}
int main()
{
print1(s); //传结构体
print2(&s); //传地址
return 0;
}上面的print1和print2函数哪个好？
答案是：print2函数
因为：
函数传参的时候，参数是需要压栈，会有时间和空间上的系统开销。
如果传递一个结构体对象的时候，结构体过大，参数压栈的的系统开销比较大，所以会导致性能的
下降。
所以：结构体传参的时候，尽量传结构体的地址
2.位段
2.1 什么是位段
位段的声明和结构体是类似的，有两个不同：
1.位段的成员必须是 int、unsigned int 或signed int 。（char也没问题）
2.位段的成员名后边有一个冒号和一个数字。
例如
struct A
{
int _a : 2;
int _b : 5;
int _c : 10;
int _d : 30;
};A就是一个位段类型
那位段A的大小是多少呢？
printf("%d\n", sizeof(struct A));答案是8
为什么是8呢？
位段 - 位：二进制位
冒号后面的数字表示的是占几个二进制位
这样的安排可以大大的节省空间，它的作用还是和结构体一样，只是比结构体更节省空间，但他还有弊端。
所以他如何使位段A节省到八个字节呢？
2.2 位段的内存分配
1. 位段的成员可以是 int， unsigned int， signed int 或者是 char （属于整形家族）类型
2. 位段的空间上是按照需要以4个字节（ int ）或者1个字节（ char ）的方式来开辟的。
（这里的意思是，如果位段的成员是int类型，那一次性开辟4个字节，不够了再开辟4个字节，如果是char类型，那一次性 开辟1个字节，不够了就在开辟一个字节）
3. 位段涉及很多不确定因素，位段是不跨平台的，注重可移植的程序应该避免使用位段。
那我们再来看看那个位段A，分析一下他的内存分配
struct A
{
int _a : 2;
int _b : 5;
int _c : 10;
int _d : 30;
};首先，它的成员是int类型，开辟32个bit位
a先用2个，还剩30个；b用5个，还剩25个；c用10个，还剩15个
d要用30个bit位，但只剩15个了，那就再开辟32个bit位，
他总的来说还是开辟了8个字节，大小是8
这里就出现问题了，剩下的那15个bit位是用了还是浪费了？
这里其实没有定论，c语言标准也没有规定，这是取决于编译器的，所以就论证了第三条：位段涉及很多不确定因素，他不是跨平台的，不同的编译器可能会有不同的结果。
还有一点要注意，数字不能超过成员类型的大小，例如_d成员是int类型，那么它所占二进制位就不能超过32。
接下来我们就验证在vs环境下位段的内存开辟和使用
struct S
{
char a : 3;
char b : 4;
char c : 5;
char d : 4;
};
int main()
{
struct S s = { 0 };
s.a = 10;
s.b = 12;
s.c = 3;
s.d = 4;
}首先给s开辟一块8bit大的空间：00000000，a占用3个bit位，从右向左占用还是从左向右呢？这个也没有标准，所以我们假定从右向左使用，
a占后3个bit位，a=10，10的二进制是1010，但a只占3个bit位，所以只能放进010
b占4个bit位，b=12，12的二进制是1100，放进1100
只剩1个bit位，假定舍弃它，再开辟8个bit位，
c=3，3的二进制是11，占5个bit位，放进00011
只剩3个bit位不够，再舍弃，重新开辟8个bit位
d=4，4的二进制是100，占4个bit位，放进0100
最终得出的是 011000100000001100000100，转化为十六进制为620304
那我们就调试起来，看看内存中是否真的是这样的
s只占3个字节，所以看前三个，真的是620304，所以再vs环境下，位段是这样存储的
位段是用来节省空间，所以不存在对齐
2.3位段的跨平台问题
1. int 位段被当成有符号数还是无符号数是不确定的。
2. 位段中最大位的数目不能确定。（16位机器最大16，32位机器最大32，写成27，在16位机
器会出问题）
3. 位段中的成员在内存中从左向右分配，还是从右向左分配标准尚未定义。
4. 当一个结构包含两个位段，第二个位段成员比较大，无法容纳于第一个位段剩余的位时，是
舍弃剩余的位还是利用，这是不确定的。
因此
跟结构相比，位段可以达到同样的效果，但是可以很好的节省空间，但是有跨平台的问题存在。
2.4 位段的应用
3.枚举
枚举顾名思义就是一一列举。
把可能的取值一一列举。
3.1枚举类型的定义
enum Day//星期
{
Mon,//0
Tues,//1
Wed,//2
Thur,//3
Fri,//4
Sat,//5
Sun//6
};
enum Sex//性别
{
MALE,//0
FEMALE,//1
SECRET//2
};
enum Color//颜色
{
RED,//0
GREEN,//1
BLUE//2
};以上定义的 enum Day ， enum Sex ， enum Color 都是枚举类型。
{}中的内容是枚举类型的可能取值，也叫 枚举常量 。
这些可能取值都是有值的，默认从0开始，一次递增1，当然在定义的时候也可以赋初值。
因为是常量，所以在使用过程中不能修改它的值
enum Color//可以全赋值
{
RED=1,
GREEN=2,
BLUE=4
};
enum Sex//也可以只赋一个或几个
{
MALE=3,
FEMALE,//4
SECRET//5
};3.2枚举的使用
一个枚举类型的大小是4字节
一个枚举变量的大小也是4字节
enum Color//颜色
{
RED=1,
GREEN=2,
BLUE=4
};
int main()
{
enum Color clr = GREEN;//只能拿枚举常量给枚举变量赋值，才不会出现类型的差异。
enum Color clr = 2；//这样写虽然编译器不报错，相当于给他赋了GREEN，但是这违法的，整形和枚举类型不一样，互不兼容
clr = 5;//这样可以吗？违法的，整形和枚举类型不一样，互不兼容
}3.3 枚举的优点
我们可以使用 #define 定义常量，为什么非要使用枚举？
枚举的优点：
1. 增加代码的可读性和可维护性
2. 和#define定义的标识符比较，枚举有类型检查，更加严谨。
3. 防止了命名污染（封装）
4. 便于调试
5. 使用方便，一次可以定义多个常量
4.联合（共用体）
4.1联合类型的定义
联合也是一种特殊的自定义类型
这种类型定义的变量也包含一系列的成员，特征是这些成员公用同一块空间（所以联合也叫共用体）。
union UN //联合类型的声明
{
char c;
int i;
};
int main()
{
union UN un; //联合变量的定义
}4.2 联合的特点
联合的成员是共用同一块内存空间的，这样一个联合变量的大小，至少是最大成员的大小（因为联
合至少得有能力保存最大的那个成员）。
union UN
{
char c;
int i;
};
int main()
{
union UN un;
printf("%d\n", sizeof(un));
printf("%d\n", &un);
printf("%p\n", &un.c);
printf("%p\n", &un.i);
}un的大小是4字节，为什么不是5呢？
再来看一下un和c和i的地址，是一样的，也就是说，c和i占同一块内存，所以un至少是4字节存放i
c和i不能同时使用，使用c的时候i不占用空间，使用i的时候，c不占用空间
有一道题：判断当前计算机的大小端存储
（之前讲过指针的做法）
union un
{
char c;
int i;
}n;
int main()
{
int a = 1;//0x 00 00 00 01
//低------------------->高
//01 00 00 00 - 小端
//00 00 00 01 - 大端
n.i = a;
if (n.c == 1)
printf("small\n");
else
printf("big\n");
}
4.3 联合大小的计算
联合的大小至少是最大成员的大小
当最大成员不是最大对齐数的整数倍的时候，就要对齐到最大对齐数的整数倍。
union Un1
{
char c[5];
int i;
};
int main()
{
printf("%d", sizeof(union Un1));
}c占5个字节，i占4个字节，所以我们可能会想，Un1的大小可能是5字节，但事实上却是8
为什么呢？
因为联合体也是存在对齐的
c的自身大小（按元素类型）是1，默认对齐数是8，对齐数是1。
i的自身大小是4，默认对齐数是8，对齐数是4。
最终对齐数是4。
最大成员的大小是5，不是4的倍数，所以浪费3个，最终大小是8
union Un2
{
short c[7];
int i;
};
int main()
{
printf("%d", sizeof(union Un2));
}c的自身大小（按元素类型）是2，默认对齐数是8，对齐数是2。
i的自身大小是4，默认对齐数是8，对齐数是4。
最终对齐数是4。
最大成员的大小是14，不是4的倍数，所以浪费2个，最终大小是16
扫一扫
937
到【灌水乐园】发言
