一篇文章带你深入理清C语言自定义类型(结构体&枚举&联合体)
自定义类型包括结构体，枚举，联合体
结构体类型
结构体是一种集合，比如数组也是一种集合，它是一组相同类型的元素的集合。
结构体描述对象，比如一本书，一个学生，它可以包含不同类型的元素。这些元素被称为成员、成员变量。
结构体的声明
#include<stdio.h>
语法：
struct tag {
member_list..
}variable_list;
struct S {
char name[20];
int age;
}s1;
struct S 是一个结构体类型，s1是这个结构体的变量(称结构体变量)
struct S {
char name[20];
int age;
}s1;
int main()
{
struct S s2; // 这种和上面的s1效果是一样的，唯一不同的是，s1是全局变量，s2是局部变量
return 0;
}
结构体不完全声明
// 匿名结构体声明
//结构体不完全声明
struct {
char i;
}a;
struct {
char name[20];
char a;
}*p;
//上面在声明的时候省略了结构体标签
// 上面的结构体只能用一次，因为没有结构体标签，构不成一个类型，有自己的局限性
int main()
{
p = &a; // 这种方法可取吗?
//警告：编译器会把上面的两个声明当成完全不同的两个类型，所以是非法的。
return 0;
}结构体的变量和初始化
struct b {
char id[10];
int age;
};
struct s{
char name[20];
int age;
char sex[4];
struct b b1;
}stu3 = {"curry",32, '男'}; // 结构体变量初始化
int main()
{
struct s stu1; // 定义结构体变量
struct s stu2 = { "权某人", 17, "男", {"C语言",190} }; //定义变量并初始化
//可以通过.和-> 访问成员
printf("%s %d %s %s %d", stu2.name, stu2.age, stu2.sex, stu2.b1.id, stu2.b1.age);
struct b b1 = {0} // 把第一个赋值为0 其他的默认为0
return 0;
}结构体的自引用
常用于描述数据结构中的链表
在结构体内部包含自身类型结构体的指针
在数据结构[数据在内存存储的结构]
例子：如果有一组数据是这样存储的：{1,2,3,4,5,6,7} ,它们的内存是连续存放的在数据结构中被称为顺序表
但是如果有一组很乱的数据：
//结构体的自引用
struct s {
char a;
//struct s s1;// 错误!!!!
struct s *s1;
};
//typedef struct b1 {
// int age;
// node* next;
//}node; // 不行错误！！！！
//正确做法：
typedef struct b2 {
int age;
struct node* next;
}node;
int main()
{
return 0;
}结构体内存对齐
了解了结构体的基本使用，在深入探讨一个问题：计算结构体的大小？
结构体的对齐规则：
- 第一个成员在与结构体偏移量为0 的地址处
其他成员变量要对齐到某个数字（对齐数）的整数倍的地址处
- 对齐数 = 编译器默认对齐数和该成员对比取其较小值作为该数对齐数
- VS默认对齐数是8
- Linux没有默认对齐这个概念，成员自身大小就是对齐数
- 如果嵌套了结构体的情况，嵌套的结构体对齐到自己的最大对齐数的整数倍处，结构体的整体大小就是所有最大对齐数（含嵌套结构体的对齐数）的整数倍。（也就是嵌套结构体内最大对齐数的整倍数）
练习1：
struct S1
{
char c1;
int i;
char c2;
};
printf("%d\n", sizeof(struct S1)); // 12分析：
练习2：
struct S2
{
char c1;
char c2;
int i;
};
printf("%d\n", sizeof(struct S2)); //8分析：
练习3：
struct S3
{
double d;
char c;
int i;
};
printf("%d\n", sizeof(struct S3)); // 16分析：
练习4结构体嵌套问题：
//练习4-结构体嵌套问题
struct S4
{
char c1;
struct S3 s3;
double d;
};
printf("%d\n", sizeof(struct S4)); // 32分析：
为什么存在结构体对齐
大部分的参考资料都是如是说的：
平台原因(移植原因)：
- 不是所有的硬件平台都能访问任意地址上的任意数据的；某些硬件平台只能在某些地址处取某些特定类型的数据，否则抛出硬件异常。
性能原因：
- 数据结构(尤其是栈)应该尽可能地在自然边界上对齐。原因在于，为了访问未对齐的内存，处理器需要作两次内存访问；而对齐的内存访问仅需要一次访问。
总体来说：结构体的内存对齐是拿空间来换取时间的做法。
在设计结构体的时候，如何做到既要满足对齐，又要节省空间？
- 让占用空间小的成员尽量集中在一起。
比如结构体的第一个成员是char，第二个成员是int，第三个成员是char，我们应该把占用空间小的成员集中在一起。char、char、int
- 会发现这些不同类型，相同个数的元素，位置不同，占用的空间大小也不同
修改默认对齐数
VS下面的默认对齐数是8，我们是来修改这个默认对齐数
通过#pargam这个预处理指令，可以改变默认对齐数
#include<stdio.h>
#pragma pack(2) // 设置默认对齐数
struct S1
{
char c1;
int i;
char c2;
};
#pragma pack()// 取消设置默认对齐数。
int main()
{
printf("%d ", sizeof(struct S1)); // 修改默认对齐为2的时候 = 8
printf("%d ", sizeof(struct S1)); // 修改默认对齐为4的时候 = 12
return 0;
}
结构在对齐方式不合适的时候，我么可以自己更改默认对齐数
百度笔试题：
写一个宏，计算结构体中某变量相对于首地址的偏移，并给出说明
考察： offsetof 宏的实现
这里还没学宏，以后在实现
结构体传参
struct a {
int data[1000];
int num;
};
void print1(struct a A)
{
printf("%d", A.num);
}
void print2(struct a* pA)
{
printf("%d", pA->num);
}
int main()
{
struct a a1 = { {1,2,3},100 };
print1(a1); // 传结构体
print2(&a1); // 传地址
//
//
//因为说传结构体，形参就相当于实参的一份临时拷贝，实参传data里面有1000个元素，加起来就4000字节，相当于在内存开辟了两份
//函数传参的时候，参数是需要压栈，会有时间和空间上的系统开销。
//如果传递一个结构体对象的时候，结构体过大，参数压栈的的系统开销比较大，所以会导致性能的下降。
return 0;
}上面那种传参形式更好？
答案是传地址更好
- 因为说传结构体，形参就相当于实参的一份临时拷贝，实参传data里面有1000个元素，加起来就4000字节，相当于在内存开辟了两份
- 函数传参的时候，参数是需要压栈，会有时间和空间上的系统开销。
- 如果传递一个结构体对象的时候，结构体过大，参数压栈的的系统开销比较大，所以会导致性能的下降。
- 结构体传参的时候，要传结构体的地址。
位段
结构体实现位段的能力。
什么是位段
位段的声明和结构体是类似的，有两个不同：
- 位段的成员必须是
int、unsigned int、或signed int char也行本质上也是int。 - 位段的成员后面有一个冒号和一个数字。
struct A {
// int 型分配四个字节 32个bit位
int _a : 5; // 5个bit位还剩27个bit位
int _b : 2; // 用上面剩余的bit位，27-2 = 剩25
int _c : 30; // 占用30个bit位，之前剩余的不够,重新开辟一个int型 32bit位 32 -30 =2
// 上面还剩2bit位,下面_d占用20bit位不够，在开辟一个int
int _d : 20;
// 上面一共开辟了三次int型，12个字节
//有效的节省了空间
};
//A 就是一个位段
//后面的数字是代表bit位
int main()
{
printf("%d", sizeof(struct A)); // 这个位段的大小是多少？ 12
return 0;
}位段的内存分配原则
- 位段的成员可以是int、unsigned int和signed int或者是char(属于整形家族)类型。
- 位段的空间上是按照需要以4个字节（int）或者1个字节（char）的方式来开辟。
- 位段涉及很多不确定因素，位段是不跨平台的，注重可移植的程序应该避免使用位段。
位段的跨平台问题
- int位段被当成有符号数还是无符号数是不确定的。
- 位段中最大位的数目不能确定。（16位机器最大16,32位机器最大32，写成27，在16位机器会出现问题）。
- 位段中的成员在内存中从左向右分配，还是从右向左分配标准尚未定义。
- 当一个结构包含两个位段，第二个位段成员比较大，无法容纳于第一个位段剩余的位时，是舍弃剩余位段还是继续利用剩余位段，这点不确定。
总结：跟结构相比，位段可以达到同样的效果，但是可以很好的节省空间，但是有跨平台的问题存在。
位段的应用
网络传参数据包，减少它的大小。
枚举
枚举顾名思义就是一一列举
把可能的取值一一列举
比如：一周的星期，可以一一列举，性别可以一一列举.... 这些固定的值。
枚举的定义
int main()
{
//比如定义成员为一个星期的可能
enum day {
Mon,
Tuesday,
Wed,
Thurs,
Friday,
Saturday,
Sunday
};
//三原色
enum RGB {
RED,
GREEN,
BLUE
};
//性别
enum Sex {
MALE,
FEMALE,
SECRET
};
//上面的 enum day， enum RGB，enum Sex 都是枚举类型
//{} 里面的内容是枚举的可能取值，也叫做枚举常量 注意是常量
//这些值如果没有初始值，默认是从0开始，依次递增+1。
return 0;
}枚举的优点
为什么使用枚举？
可以使用#defined定义常量，为什么非要使用枚举？
枚举的优点：
- 增加代码的可读性和可维护性
- 和#define定义的标识符比较枚举有类型检查，更加严谨。
- 防止了命名污染
便于调试
- 相对于#define,#deine是在预编译阶段完成了替换。
- 使用方便，一次可以定义多个常量
枚举的使用
1.
int main()
{
enum Color {
Orange, // 0
Pink = 4, // 这里赋值了后面的值就根据这个值依次递增+1
Black // 5
};
//color = 3 不行！！
enum Color color = Pink; // 枚举变量的值，只能拿枚举常量给枚举变量赋值才不会出现类型的差异
return 0;
}
2.
void menu()
{
printf("*****************************\n");
printf("***** 1.Add 2.Sub ******\n");
printf("***** 3.Mul 4.Div ******\n");
printf("******** 0.exit *******\n");
}
int main()
{
enum Select
{
EXIT, // 0
Add, // 1
Sub, // 2
Mul, // 3
Div //4
//默认是0 依次递增+1
};
int input = 0;
do {
menu();
printf("请输入：>");
scanf("%d", &input);
switch (input)
{
case EXIT :
break;
case Add :
break;
case Sub:
break;
case Mul :
break;
case Div :
break;
default:
break;
}
} while (input);
return 0;
}联合体（共用体）
联合体也是一种特殊的自定义类型，特征是这些成员共用一块内存空间（所以也叫共用体）。
联合类型的定义
int main()
{
//联合体也是一种特殊的自定义类型，特征是这些成员共用一块空间，所以也叫共用体
union u {
char c;
int i;
};
//union u 是一个联合体类型
union u u1; // 联合变量的定义
}联合的特点
联合的成员共用一块空间，这样一个联合的大小，至少是最大成员的大小（因为联合至少有能力能存放最大的那个成员）。
int main()
{
union u {
char c;
int i;
};
union u u1 = {1};
printf("%p\n", &(u1.c)); //
printf("%p\n", &(u1.i)); //
printf("%p\n", &u1); // 这三个地址是一样的
printf("%d\n", sizeof(u1.c));
printf("%d\n", sizeof(u1.i));
printf("%d\n", sizeof(u1)); // 4 共用体的大小怎么计算？
return 0;
}联合大小的计算
- 联合的大小至少是最大成员的大小。
- 联合也存在内存对齐。当最大成员大小不是最大对齐数的整倍数的时候，就要对齐到最大对齐数的整倍数。
例：
int main()
{
union u1 {
char c[6]; // 7
int i; // 4
//c是这个数组，有6个元素，是这个联合最大的成员，i是这个联合的最大对齐数，这个最大成员7不是最大对齐的整倍数，就要对齐到这个最大对齐数的整倍数，8
//当最大成员大小不是最大对齐数的整倍数的时候，就要对齐到最大对齐数的整倍数
};
union u2 {
short c[7]; // 总大小14，一个占两个字节，有7个。
int i; // 4 最大对齐数，最大成员不是最大对齐数的整倍数，要对齐到最大对齐数的整倍数，16
};
printf("%d ", sizeof(union u1));
printf("%d", sizeof(union u2));
return 0;
}本作品采用 知识共享署名-相同方式共享 4.0 国际许可协议 进行许可。
评论已关闭