十二.自定义类型：结构体、联合、枚举

创始人

2024-05-11 17:28:47

0次

一.结构体

1.结构体类型的基础知识

（1）结构的声明

（2）匿名结构体

（3）结构体变量的定义和初始化

（4）结构的自引用

（5）结构体传参

2.结构体内存对齐

（1）计算一个结构体的大小

（2）修改默认对齐数

3.结构体实现位段

（1）何为位段

（2）位段的内存分配方式

（3）位段的跨平台问题

二.枚举

1.枚举类型的定义

2.枚举的优点

3.枚举的使用

三.联合

1.联合类型的定义

2.联合大小的计算

3.联合的实际运用

一.结构体

1.结构体类型的基础知识

（1）结构的声明

结构体是一些值的集合，这些值称为成员变量。结构的每个成员可以是不同类型的变量。

struct tag
{member-list;
}variable-list;

例：描述一个学生

struct Stu
{char name[20]; // 名字int age; // 年龄char sex[5]; // 性别char id[20]; // 学号
}; // 分号不能丢

（2）匿名结构体

在声明结构的时候，可以不完全声明。匿名结构体在声明时省略掉结构体标签（tag），因为没有结构体标签导致无法构成类型，所以匿名结构体自然只能用一次。

例：

struct
{int a;char b;float c;double d;
} s;struct
{int a;char b;float c;double d;
} *ps;

注：如果进行下述操作，是非法的

int main()
{ps = &s; // errorreturn 0;
}

因为在编译器看来，虽然成员是一模一样的，但是编译器仍然认为它们是两个完全不同的类型，所以 *ps 不能存变量 s 的地址。

（3）结构体变量的定义和初始化

声明类型的同时直接创建变量：

struct S
{char c;int i;
} s1, s2; // 声明类型的同时创建变量int main()
{struct S s3, s4;return 0;
}

typedef重定义结构体类型：

typedef struct S
{char c;int i;
} s; // 定义S为结构体类型int main()
{S s3, s4;  //用S声明结构体变量return 0;
}

创建变量的同时赋值（初始化）

struct S
{char c;int i;
} s1, s2;int main()
{struct S s3 = {'x', 20};return 0;
}

构体包含结构体的初始化方法：

struct S
{char c;int i;
} s1, s2;struct B
{double d;struct S s;char c;
};int main()
{struct B sb = {3.14, {'w', 100}, 'q'};printf("%lf %c %d %c\n", sb.d, sb.s.c, sb.s.i, sb.c);return 0;
}

（4）结构的自引用

结构体中包含一个类型为该结构体本身的成员，包含同类型的结构体指针（不是包含同类型的结构体变量）

例：

struct A
{int i;char c;
};struct B
{char c;struct A sa;double d;
};

注：结构体不能自己包含自己，不能包含同类型的结构体变量

错误演示：

struct N
{int d;struct N n; // 结构体里不能存在结构体自己类型的成员
};

为了加深理解，我们引入数据结构中的一些知识：

所以结构体正确的自引用为：

typedef struct Node
{int data;struct Node* next;
} Node;

（5）结构体传参

结构体有两种传参方式：传结构体和传结构体的地址

观察以下代码：

#include 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.结构体内存对齐

（1）计算一个结构体的大小

#include struct S
{char c1;  // 1int i;    // 4char c2;  // 1
};int main()
{struct S s = { 0 };printf("%d\n", sizeof(s));return 0;
}

运行结果： 12

为什么是12字节呢？与传统的类型不同，这涉及到结构体内存对齐的问题：

结构体的对齐规则：

结构体的第一个成员放在结构体变量在内存中存储位置的0偏移处开始。
从第2个成员往后的所有成员，都要放在一个对齐数（成员的大小和默认对齐数的较小值）的整数倍的地址处。VS中默认对齐数为8！
结构体的总大小是结构体的所有成员的对齐数中最大的那个对齐数的整数倍。
如果嵌套了结构体的情况，嵌套的结构体对齐到自己的最大对齐数的整数倍处，结构体的整体大小就是所有最大对齐数（含嵌套结构体的对齐数）的整数倍。

注：VS中默认对其数为8，Linux中没有默认对齐数概念！

练习1;

#include struct S2
{char c;int i;double d;
};int main()
{struct S2 s2 = {0};printf("%d\n", sizeof(s2));return 0;
}

运行结果：16

解析如下：

练习2：

#include struct S3
{char c1;char c2;int i;
};int main()
{struct S3 s3 = { 0 };printf("%d\n", sizeof(s3));return 0;
}

运行结果：8

解析如下：

练习3：

#include struct S4
{double d;char c;int i;
};int main()
{struct S4 s4 = { 0 };printf("%d\n", sizeof(s4));return 0;
}

运行结果：16

解析如下：

结构体嵌套的内存对齐：

如果嵌套了结构体的情况，嵌套的结构体对齐到自己的最大对齐数的整数倍处，结构体的整体大小就是所有最大对齐数（含嵌套结构体的对齐数）的整数倍：

#include struct S4
{double d;char c;int i;
};
struct S5
{char c1;struct S4 s4;double d;
};int main()
{struct S5 s5 = {0};printf("%d\n", sizeof(s5));return 0;
}

运行结果：32

解析如下：

那么为什么会出现内存对齐呢?

平台原因(移植原因)：不是所有的硬件平台都能访问任意地址上的任意数据的；某些硬件平台只能在某些地址处取某些特定类型的数据，否则抛出硬件异常。
性能原因：数据结构（尤其是栈）应该尽可能地在自然边界上对齐。原因在于，为了访问未对齐的内存，处理器需要作两次内存访问；而对齐的内存访问仅需要一次访问。
结构体的内存对齐是拿空间来换取时间的做法。

在设计结构体时，如何做到既满足对齐又能节省空间呢？

答：让空间小的成员尽量集中在一起。

struct S1
{char c1;int i;char c2;
};struct S2
{char c1;char c2;int i;
};

虽然S1和S2类型的成员一模一样，但是通过让空间小的成员尽量计中在一起，使所占空间的大小有了一些区别。

（2）修改默认对齐数

预处理指令 #pragma 可以改变我们的默认对齐数。

#include // 默认对齐数是8
#pragma pack(2)  //把默认对齐数改为2
struct S
{char c1;  //1int i;    //4char c2;  //1
};#pragma pack()  //重置默认对齐数
int main()
{printf("%d\n", sizeof(struct S)); //12return 0;    
}

运行结果：8

解析如下：

结构体在对齐方式不合适的时候，我们可以通过使用 #pragma 自行修改默认对齐数

3.结构体实现位段

（1）何为位段

定义：位段，C语言允许在一个结构体中以位为单位来指定其成员所占内存长度，这种以位为单位的成员称为“位段”或称“位域”( bit field) 。利用位段能够用较少的位数存储数据。

位段的声明和结构体是类似的，但有两个不同点：

位段的成员只能是： int、unsigned int、signed int
位段的成员名后面有一个冒号和一个数字：member_name : number

例：

struct A
{int _a:2;int _b:5;int _c:10;int _d:30;
}// A就是一个位段类型

那么位段A的大小是多少呢？

#include struct A
{int _a:2;  // _a 成员占2个比特位int _b:5;  // _b 成员占5个比特位int _c:10; // _c 成员占10个比特位int _d:30; // _d 成员占30个比特位
};int main()
{printf("%d\n", sizeof(struct A));return 0;
}

运行结果：8

位段A里有4个成员占47个比特位，而8个字节占64个比特位，为什么呢？

（2）位段的内存分配方式

位段的意义：位段在一定程度上帮助我们节省空间。

但是有以下几点需要注意：

位段的成员可以是 int、unsigned int、signed int 或者是 char （属于整形家族）类型。
位段的空间上是按照需要以4个字节（ int ）或者1个字节（ char ）的方式来开辟的。
位段涉及很多不确定因素，位段是不跨平台的，注重可移植的程序应该避免使用位段。

那空间是如何开辟的呢？

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;
}

（vs2022环境下）

（3）位段的跨平台问题

int 位段被当成有符号数还是无符号数是不确定的。
位段中最大位的数目不能确定。比如16位机器最大16，32位机器最大32，写成27，在16位机器会出问题。
位段中的成员在内存中从左向右分配，还是从右向左分配标准尚未定义。
当一个结构包含两个位段，第二个位段成员比较大，无法容纳于第一个位段剩余的位时，是舍弃剩余的位还是利用，这是不确定的。

所以，跟结构体相比，位段可以达到同样的效果，但位段可以更好地节省空间，缺陷是存在跨平台问题。

二.枚举

1.枚举类型的定义

枚举顾名思义就是一一列举，把可能的取值一一列举，比如我们现实生活中：
一周星期一到星期日是有限的7天，可以一一列举。
性别有：男、女、保密，也可以一一列举。
月份有12个月，也可以一一列举
这里就可以使用枚举了：

typedef [attributes] enum [tag]
{enumlist;
}enumname;

代码演示：

enum Day //星期
{// 枚举常量Mon,Tues,Wed,Thur,Fri,Sat,Sun
};enum Sex //性别
{// 枚举常量MALE,FEMALE,SECRET
};enum Month //颜色
{// 枚举常量JANUARY,FEBRUARY,MARCH,……，DECENMBE
};

上述代码定义的 enum Day，enum Sex，enum Month 都是枚举类型。{ } 中的内容是枚举类型的可能取值，即枚举常量。这些可能取值都是有值的，默认从0开始，依次递增1。当然，可以在定义的时候也可以对其赋予初值，例如：

enum Sex //性别
{// 枚举常量MALE=1, //赋初值FEMALE=2,SECRET=4
};

2.枚举的优点

我们可以用 #define 定义常量，为什么非要使用枚举？

枚举的优点：

增加代码的可读性和可维护性。
与 #define 定义的标识符相比，枚举有类型检查，更加严谨。
有效防止命名污染（封装）。
便于调试。
使用方便，一次可以定义多个常量。

3.枚举的使用

代码演示：

#include enum Color //颜色
{RED = 1,GREEN = 2,BLUE = 4
};int main()
{enum Color c = GREEN;c = 5;printf("%d\n", c);return 0;
}

运行结果：5

由此可见，枚举常量虽然是不能改变的，但是通过枚举常量创造出来的变量是可以改变的！

实际运用：这是之前写过的简易计算器

#include void menu()
{printf("*****************************\n");printf("**    1. add     2. sub    **\n");printf("**    3. mul     4. div    **\n");printf("**         0. exit         **\n");printf("*****************************\n");
}int main()
{int input = 0;do {menu();printf("请选择:> ");scanf("%d", &input);switch {case 1:break;case 2:break;case 3:break;case 4:break;case 0:break;default:break;} while (input);return 0;
}

阅读代码的时候如果不看上面的 menu，是很难知道 case 中的 12340 分别是什么的。1 为什么是加？2 为什么是减？看到数字的时候联想不到它的到底是干什么的。

为了提高代码的可读性，我们可以使用枚举来解决：

#include void menu() {...}enum Option
{EXIT, // 0ADD,  // 1SUB,  // 2MUL,  // 3DIV,  // 4
};int main()
{int input = 0;do {menu();printf("请选择:> ");scanf("%d", &input);switch {case ADD: // 替换后就好多了，代码的可读性大大增加break;case SUB:break;case MUL:break;case DIV:break;case EXIT:break;default:break;} while (input);return 0;
}

三.联合

1.联合类型的定义

联合又称共用体，是一种特殊的自定义类型。可以在相同的内存位置存储不同的数据类型。可以定义一个带有多成员的联合体，但是任何时候只能有一个成员带有值。

#include union Un
{char c; // 1int i; // 4
};int main()
{union Un u; // 创建一个联合体变量printf("%d\n", sizeof(u)); // 计算联合体变量的大小return 0;
}

运行结果：4

2.联合大小的计算

为什么是4个字节呢？我们来看一下联合是如何开辟内存空间的

#include union Un
{char c; // 1int i; // 4
};int main()
{union Un u;printf("%p\n", &u);printf("%p\n", &(u.c));printf("%p\n", &(u.i));return 0;
}

运行结果：

解析如下：

结论：

联合的大小至少是最大成员的大小。
当最大成员大小不是最大对齐数的整数倍的时候，就要对齐到最大对齐数的整数倍

3.联合的实际运用

写一段程序判断机器是大端还是小端？

思路：用int类型的1来验证，通过判断四个字节中的第一个字节，如果是小段，第一个字节存放的是01，如果是大端，第一个字节存放的是00.

朴素版：

#include int main()
{int a = 1;if ( ( *(char*)&a ) == 1 )printf("小端\n");elseprintf("大端\n");return 0;
}

使用联合判断：

#include int main()
{union U {char c;int i;} u;u.i = 1;if(u.c == 1)printf("小端\n");elseprintf("大端\n");return 0;
}

本篇到此结束，码文不易，还请多多支持哦！

词库加载错误:未能找到文件“E:\highferrum_mysql\Configuration\Dict_Stopwords.txt”。

上一篇：day03 链表 | 203、移除链表元素 707、设计链表 206、反转链表

下一篇：ssm权限管理系统2

十二.自定义类型：结构体、联合、枚举

一.结构体

1.结构体类型的基础知识

（1）结构的声明

（2）匿名结构体

（3）结构体变量的定义和初始化

（4）结构的自引用

（5）结构体传参

2.结构体内存对齐

（1）计算一个结构体的大小

（2）修改默认对齐数

3.结构体实现位段

（1）何为位段

（2）位段的内存分配方式

（3）位段的跨平台问题

二.枚举

1.枚举类型的定义

2.枚举的优点

3.枚举的使用

三.联合

1.联合类型的定义

2.联合大小的计算

3.联合的实际运用

相关内容

热门资讯