【C语言】自定义类型：结构体、枚举、联合-Toy模板网

这篇具有很好参考价值的文章主要介绍了【C语言】自定义类型：结构体、枚举、联合。希望对大家有所帮助。如果存在错误或未考虑完全的地方，请大家不吝赐教，您也可以点击"举报违法"按钮提交疑问。

前言：

一、结构体

（1）结构体的特殊声明

（2）结构体的自引用

（3）结构体嵌套初始化

（4）结构体内存对齐

（5）修改默认对齐数

（6）结构体传参

（7）位段

二、枚举

（1）枚举的定义

（2）枚举的优点

（3）枚举的使用

三、联合（共用体）

（1）联合类型的定义

（2）联合的特点

（3）联合大小的计算

前言：

本篇重点为结构体内存对齐与位段的概念，该知识点是一个非常热门的考点，相信本篇文章会给你带来收获，博主会持续更新C语言的进阶知识，感兴趣的读者可以关注博主动态🌟🌟🌟

一、结构体

（1）结构体的特殊声明

我们知道结构体的声明大概为下面的方式：

struct tag
{
    member - list;//成员变量列表
}variable - list;//变量列表

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

在声明结构的时候，可以不完全的声明。

比如：

//匿名结构体类型
struct
{
    int a;
    char b;
    float c;
}x;
struct
{
    int a;
    char b;
    float c;
}a[20], * p;

上面的两个结构在声明时省略了结构体标签tag，这种被称为匿名结构体。

我们发现两个结构体的成员变量是完全一致的，那么我们可不可以认为上面的两个结构体是相同类型的呢？

//在上面代码的基础上，下面的代码合法么？
p = &x;

答案是不能，因此该代码也不合法，原因在于编译器会把上面的两个声明当成完全不同的两个类型。

（2）结构体的自引用

这里的自引用指的是指针，即结构体中可以包含该结构体类型的指针，如：

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

而不可以是：

struct Node
{
    int data;
    struct Node next;
};
//err

原因在于其自身类型大小无法计算

即sizeof(struct Node)是多少？你会发现他会无穷的一直计算下去。

刚才学习了匿名结构体，那么我们看下面的代码是否可行：

//代码3
typedef struct
{
	int data;
	Node* next;
}Node;//err

答案是不行的，原因在于该匿名结构体省略了结构体标签tag，

也就是说，Node的声明在Node* next之后，即还没有创建Node，就要使用。

（3）结构体嵌套初始化

struct Point
{
	int x;
	int y;
}p1;

struct Node
{
	int data;
	struct Point p;
	struct Node* next;
}n1 = { 10, {4,5}, NULL }; //结构体嵌套初始化

struct Node n2 = { 20, {5, 6}, NULL };//结构体嵌套初始化

像上面这种结构体中包含了另一个结构体初始化的情况就叫做结构体嵌套初始化。

（4）结构体内存对齐

接下来我们来学习如何计算结构体的大小，其涉及到了结构体内存对齐的概念，也是本篇最为重要的内容。

首先给出两个结构体，你认为他的大小为多少？

//练习1
struct S1
{
	char c1;
	int i;
	char c2;
};//6？

//练习2
struct S2
{
	char c1;
	char c2;
	int i;
};//6？

在学习结构体内存对齐前，你可能认为两个都为6，但是实际上为12和8。

也就是说结构体中有的成员变量之间存在空隙，浪费了一定的空间。

那么空隙如何计算呢？

宏：offsetof( type, member )（函数不能传参类型，但宏可以）

使用此宏需引用头文件stddef.h，该宏可以计算结构体成员相较于结构体起始位置的偏移量。

如图：

【C语言】自定义类型：结构体、枚举、联合,C语言,c语言,开发语言,学习,程序人生,笔记

我们发现结构体大小的计算不是那么简单，那么结构体大小遵从什么样的规则呢？

结构体的对齐规则：

第一个成员在与结构体变量偏移量为0的地址处。
其他成员变量要对齐到某个数字（对齐数）的整数倍的地址处。
结构体总大小为最大对齐数（每个成员变量都有一个对齐数）的整数倍。
如果嵌套了结构体的情况，嵌套的结构体对齐到自己的最大对齐数的整数倍处，结构体的整体大小就是所有最大对齐数（含嵌套结构体的对齐数）的整数倍。

对齐数=编译器默认的一个对齐数与该成员大小的较小值。

这里数组比较特殊，它的大小为数组元素类型的大小，而不是整个数组的大小，比如char c[5]，他的大小为1，若默认对齐数为8，则对齐数取较小为1。

VS中默认的值为8。gcc编译器无默认对齐数，对齐数就是结构体成员自身大小。

学习了如何计算，那我们来尝试两道题：

//练习1
struct S1
{
    double d;
    char c;
    int i;
};

//练习2-结构体嵌套问题
struct S2
{
    char c1;
    struct S1 s1;
    double d;
};

答案：S1大小16，偏移量分别为0、8、12；

S2大小32，偏移量分别为0、8、24。

练习1分析：

【C语言】自定义类型：结构体、枚举、联合,C语言,c语言,开发语言,学习,程序人生,笔记

练习2分析：

【C语言】自定义类型：结构体、枚举、联合,C语言,c语言,开发语言,学习,程序人生,笔记

那么为什么要这样设计，为什么存在内存对齐呢？

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

解释一下两次内存访问的情况：

以32位机器举例：32位机器字长32位（bit），即一次读写数据32位（bit），对应4个字节（byte）。

假设在不对齐的情况下：

【C语言】自定义类型：结构体、枚举、联合,C语言,c语言,开发语言,学习,程序人生,笔记

所以说：结构体的内存对齐是拿空间来换取时间的做法。

在设计结构体的时候，我们既要满足对齐，又要节省空间就需要让占用空间小的成员尽量集中在一起。比如：

//例如：
struct S1
{
	char c1;
	int i;
	char c2;
};
struct S2
{
	char c1;
	char c2;
	int i;
};

S1和S2类型的成员一模一样，但是S2在设计时让占用空间小的char集中在一起，所以S2的占用空间小于S1的占用空间。

（5）修改默认对齐数

如果你觉得该编译器的默认对齐数不合适，那么我们可以自行修改，方法如下：

#pragma pack(8)//设置默认对齐数为8
struct S1
{
	char c1;
	int i;
	char c2;
};
#pragma pack()//取消设置的默认对齐数，还原为默认

（6）结构体传参

结构体作为参数传递时我们要传递结构体本身还是结构体指针呢？

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

如果是你，你选择那个打印函数？

答案：首选print2函数。

原因：函数传参的时候，参数是需要压栈，会有时间和空间上的系统开销。

如果传递一个结构体对象的时候，结构体过大，参数压栈的的系统开销比较大，所以会导致性能的下降。

结论：结构体传参的时候，要传结构体的地址。

（7）位段

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

位段的成员必须是int、unsigned int、signed int或者是char（属于整型家族）类型。
位段的成员名后边有一个冒号和一个数字。

比如：

struct A
{
	int _a : 2;
	int _b : 5;
	int _c : 10;
	int _d : 30;
};

【C语言】自定义类型：结构体、枚举、联合,C语言,c语言,开发语言,学习,程序人生,笔记

A就是一个位段类型。

位段是为了节省内存来设计的，比如有些数字两个bit就能放下：

如0，1，2，3 对应00，01，10，11。

那么位段A的大小又如何计算呢？

位段的内存分配：

位段的成员可以是 int、unsigned int、signed int或者是char（属于整形家族）类型

位段的空间上是按照需要以4个字节（ int ）或者1个字节（ char ）的方式来开辟的，具体是哪种取决于编译器。

C语言没有明确规定位段的空间开辟方式，位段涉及很多不确定因素，位段是不跨平台的，注重可移植的程序应该避免使用位段。

【C语言】自定义类型：结构体、枚举、联合,C语言,c语言,开发语言,学习,程序人生,笔记

上图为VS2013编译器的调试结果，该编译器的规则是，每个字节从右向左赋值，空间不够了就舍弃进入下一个字节内部继续存储。

关于位段的跨平台问题：

int位段被当成有符号数还是无符号数是不确定的。

位段中最大位的数目不能确定。（16位机器最大16，32位机器最大32，写成27，在16位机器会出问题。

位段中的成员在内存中从左向右分配，还是从右向左分配标准尚未定义。（VS从右向左分配，如上图）

当一个结构包含两个位段，第二个位段成员比较大，无法容纳于第一个位段剩余的位时，是舍弃剩余的位还是利用，这是不确定的（VS舍弃，如上图）。

总结：跟结构相比，位段可以达到同样的效果，但是可以很好的节省空间，但是有跨平台的问题存在。

位段的应用：

【C语言】自定义类型：结构体、枚举、联合,C语言,c语言,开发语言,学习,程序人生,笔记

上图为IP数据包的格式，我们发现数据的每行都是32位，再结合位段的使用，节省了空间。

二、枚举

（1）枚举的定义

enum Day//星期
{
	Mon,  //0
	Tues, //1
	Wed,  //2
	Thur,
	Fri,
	Sat,
	Sun
};

enum Color//颜色
{
	RED,     //0
	GREEN=2, //2
	BLUE     //3
};

enum Day，enum Color是枚举类型，{}中的内容是枚举类型的可能取值，也叫枚举常量。

枚举常量的值默认从0开始，每次递增1，在定义时也可以附初值。

（2）枚举的优点

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

枚举的优点：

增加代码的可读性和可维护性。

和#define定义的标识符比较枚举有类型检查，更加严谨。(见枚举的使用)

防止了命名污染（封装）。

便于调试。

使用方便，一次可以定义多个常量。

另外如果大家想更直观的了解到枚举的优点，请移步博客：通讯录的实现。

（3）枚举的使用

enum Color//颜色
{
 RED=1,
 GREEN=2,
 BLUE=4
};
enum Color clr = GREEN;//只能拿枚举常量给枚举变量赋值，才不会出现类型的差异。
clr = 5;               //err

clr为enum Color类型，5为int类型，枚举有类型检查，赋值失败。

只有枚举常量能赋值给枚举变量。

三、联合（共用体）

（1）联合类型的定义

联合也是一种特殊的自定义类型，这种类型定义的变量也包含一系列的成员，特征是这些成员共用同一块空间（所以联合也叫共用体）。比如：

//联合类型的声明
union Un
{
	char c;
	int i;
};
//联合变量的定义
union Un un;
//计算连个变量的大小
printf("%d\n", sizeof(un));

（2）联合的特点

联合的成员是共用同一块内存空间的，这样一个联合变量的大小，至少是最大成员的大小（因为联合至少得有能力保存最大的那个成员）。

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

答案：第一部分结果相同，第二部分打印11223355。

分析：联合体公用同一块内存空间，所以他们的地址是相同的，只不过整型i占四个字节，字符c占一个字节，由于是小端字节序存储，所以0x11223344放在内存中的结果是44332211，0x55在内存中替换掉一个字节44，为55332211，打印出来为11223355。

你能利用联合的特点测试一下你的机器是大端字节序还是小端字节序存储么？

int check_sys()
{
	union
	{
		int i;
		char c;
	}un = {.i = 1};
	return un.c;
}

int main()
{
	int ret = check_sys();
	if (ret == 1)
		printf("小端\n");
	else
		printf("大端\n");

	return 0;
}

（3）联合大小的计算

联合大小的计算基于两个规则：

联合的大小至少是最大成员的大小。

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

考察一下你是否明白如何计算了？：

union Un1
{
	char c[5];//5 1 8 1
	int i;//4 8 4
};

union Un2
{
	short c[7];//14 2 8 2
	int i;//4 4 8 4
};

int main()
{
	printf("%d\n", sizeof(union Un1));//5+3 = 8
	printf("%d\n", sizeof(union Un2));//16
	return 0;
}

与结构体类似首先需要计算对齐数，再根据上面的两个规则进行判断。

对于Un1：char c[5]的大小为1，VS默认对齐数为8，取较小为1；int i的大小为4，VS默认对齐数为8，取较小为4，该联合体最大对齐数为4，最大成员大小为5，所以需要扩大到4的整数倍8，所以第一个打印结果为5+3=8。

对于Un2：short c[7]的大小为2，VS默认对齐数为8，取较小为2；int i的大小为4，VS默认对齐数为8，取较小为4，该联合体最大对齐数为4，最大成员大小为14，所以需要扩大到4的整数倍16，所以第一个打印结果为14+2=16。

学习完自定义类型后，博主会在后续对于这部分知识实践应用，完成一个通讯录程序，感兴趣的读者可以关注博主动态🔥🔥🔥文章来源地址https://www.toymoban.com/news/detail-565365.html

到了这里，关于【C语言】自定义类型：结构体、枚举、联合的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！