深度刨析自定义类型（结构体、枚举、联合）

Yui_

于 2024-07-20 08:52:23 发布

阅读量1.2k

点赞数 38

分类专栏： C语言文章标签： c语言算法机器学习经验分享开发语言

本文链接：https://blog.csdn.net/2303_79015671/article/details/140565072

版权

C语言专栏收录该内容

28 篇文章 0 订阅

订阅专栏

1.结构体

1.1 结构体的基础知识

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

1.2 结构体的声明

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

当我们要描述一个学生时，学生具有复杂的属性如姓名、年龄、性别、学号等等,就要用到结构体

struct stu
{
	char name[20];
	int age;
	char sex[10];
	char id[20];
};//一定要写分号

1.3 特殊的声明

在声明结构的时候，可以不完全的声明。也就是匿名结构体。

匿名结构体只能在定义时初始化，一般情况只能用一次

struct
{
	int a;
	char b;
	float c;
}x;
struct 
{
	int a;
	char b;
	float c;
}a[20],*p;

上面的两个结构在声明的时候省略掉了结构体的标签（tag）
提问，下面的代码合法吗？

struct
{
	int a;
	char b;
	float c;
}x;
struct 
{
	int a;
	char b;
	float c;
}a[20],*p;

p = &x;

回答：不合法，即使结构体里面定义的类型都相同编译器也会把它们两当成不同的两个类型。因为类型不同，p不能接受x的地址。

1.4 结构体的自引用

提问：在结构体中包含了一个类型位该结构体本身的成员是否可以呢？
回答：可以，但要注意一下形式。

//代码1
struct Node
{
	int data;
	struct Node next;
};
//错误写法！如果这样是可行的话，那么这个结构体的类型将会无穷大，因为该结构体中的会包含下一个结构体，
//下一个结构体又会包含一个结构体，这样无穷循环下去站用的空间就会无穷大了。

//正确的自引用方式
//代码2
struct Node
{
	int data;
	struct Node* next;
};
//该结构体内只会存放下一个结构体的地址，指针的大小只有4或者8个字节。

注意

//代码3
typedef struct
{
	int data;
	Node* next;
}Node;
//这样写代码是错误的，typedef定义的Node，是不能放在结构体内部使用的。Node本来就是定义这个结构体的，怎么会在定义的过程中就让你使用呢。

//正确写法
//代码4
typedef struct Node
{
	int data;
	strude Node* next;
}Node:

1.5 结构体变量的定义和初始化

有了结构体类型，那如何定义变量，其实很简单。

struct Point
{
	int x;
	int y;
}p1;                   //声明类型的同时定义变量p1

struct Point p2;       //定义结构体变量p2

//初始化：定义变量的同时赋初值。
struct Point p3 = {x,y};

struct stu
{
	char name[20];
	int age;
};
sstruct stu s = {"yui",17};//初始化

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

struct Node n2 = {20.{2,3},NULL};//结构体嵌套初始化

1.6 结构体内存对齐

在掌握了结构体的基本使用后，现在我们来深入讨论一个问题：结构体的大小要怎么计算呢？
为了知道结构体的大小，我们就需要了解结构体内存对齐
先说明一下对齐规则吧：
对齐规则：

结构体的第一个成员永远放在偏移量为0的位置

从第二个成员开始，往后的每个成员都要对齐到某个对齐数的整数倍处。对齐数：结构体成员自身的大小和默认对齐数的较小值。VS的默认对齐数是8。gcc没有默认对齐数，对齐数就是结构体成员的自身大小

结构体的总大小，必须是最大对对齐数的整数倍，最大对齐数是：所有成员的对齐数的最大的值

如果嵌套了结构体，嵌套的结构体对齐到自己最大对齐数的整数倍处

1.6.1 练习1

#include <stdio.h>
struct s1
{
	char c1;
	int i;
	char c2;
};

struct s2
{
	char c1;
	char c2;
	int i;
};

int main()
{
	struct s1 s_1;
	struct s2 s_2;
	printf("struct s1:%d\n",sizeof(s_1));
	printf("struct s2:%d\n",sizeof(s_2));
	return 0;
}
//打印结果：
/*
struct s1:12
struct s2:8
*/

因为内存对齐的原因也就导致了，明明两个结构体的内容中的类型都是一模一样的只是位置不同而已，却导致了结构体的大小不同。
根据内存对齐规则，s1在内存中是这样存放的。

对齐完了后计算大小，根据对齐规则3。结构体大小必须是最大对对齐数的整数倍，这里的内存大小已经来到了9同时这个结构体的最大对齐数是4，而9不是4的倍数，那么就选择用到大小为12的位置了。
内存对齐规则

同样的来画结构体s2的对齐图，不过这次就不会解释了。
内存对齐规则

根据对齐规则3，结构体大小必须是最大对对齐数的整数倍，这里的内存大小已经来到了8同时这个结构体的最大对齐数是4，8刚好是4的倍数，所以这个结构体的大小就是8了。

1.6.2 练习2

#include <stdio.h>
struct s3
{
	double d;
	char c;
	int i;
};
int main()
{
	struct s3 s_3;
	printf("struct s3:%d\n",sizeof(s_3));
	return 0;
}
//打印结果：
//struct s3:16

内存对齐规则

最大对齐数是8，16刚好是8的倍数。

1.6.3 练习3

#include <stdio.h>

struct s3
{
	double d;
	char c;
	int i;
};

struct s4
{
	char c1;
	struct s3 s_3;
	double d;
};
int main()
{
	struct s4 s_4;
	printf("struct s4:%d\n",sizeof(s_4));
	return 0;
}
//打印结果：
//struct s4:32

内存对齐规则

最大对齐数是8(vs默认对齐数)，32刚好是8的倍数。

为什么要有内存对齐

目前有两个说法

1. 平台原因（移植原因）
不是所有的硬件平台都能访问任意地址上的任意数据，某些硬件平台只能在某些地址处取某些特定类型的数据，否则就会抛出异常。

2. 性能原因：
数据结构（尤其是栈）应该尽可能在自然边界上对齐。
原因在于，为了访问未对齐的内存，处理器需要作两次内存访问，而对齐的内存访问仅需要一次访问。

也就是说：

结构体的内存对齐是拿空间来换时间的做法

在设计结构体的时候，为了节省空间，我们可以让空间小的成员尽量集中在一起。

#include <stdio.h>
struct s1
{
	char c1;
	int i;
	char c2;
};

struct s2
{
	char c1;
	char c2;
	int i;
};

int main()
{
	struct s1 s_1;
	struct s2 s_2;
	printf("struct s1:%d\n",sizeof(s_1));
	printf("struct s2:%d\n",sizeof(s_2));
	return 0;
}
//打印结果：
/*
struct s1:12
struct s2:8
*/

s1和s2的类型成员一模一样，但是s1和s2所占空间的大小有区别。

1.7 修改默认对齐数

在vs编译器上，#pragma这个预处理指令可以改变vs上的默认对齐数。

#include <stdio.h>
#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;
};
int main()
{
	printf("struct s2:%d\n",sizeof(struct s2));
	return 0;
}
//打印结果：
//struct s2:6

结构在对齐方式不合适的时候，我们可以自己更改默认对齐数。(修改的默认对齐数最好是2的倍数)

1.8 结构体的传参

#include <stdio.h>
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.位段的成员必须是整型家族的成员
2.位段的成员后面有一个冒号和一个数字。

位段成员标注的数字是二进制位。

比如

struct S
{
	char a : 3;
	char b : 4;
	char c : 5;
	char d : 4;
};

S就是一个位段类型。
那位段S的大小是多少？

2.2 位段的内容分配

位段的成员是整型家族类型
位段的空间上是按照需要以4个字节（int）或者1个字节（char）的方式来开辟的。
位段涉及很多不确定的因素，位段是不跨平台的，注重可移植的程序要避免使用位段。
位段内容分配的规则：
位段的空间上是按照需要以4个字节（int）或者1个字节（char）的方式来开辟的，分配时按比特位来分配，从右往左分配，如果剩余空间不够存放下一变量的位段就直接新开一部分空间分配。

以该题为例

#include <stdio.h>
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;
	printf("%d\n", sizeof(struct S));
	return 0;
}
//打印结果：
//3

分配方式如图

下面来验证是否真的是这样分配的，按上面的要求进行赋值，空间不够的会直接裁剪掉二进制的右边如a的大小只有3个bit，而10的二进制位是1010，那就会被裁剪成010放进a中。
还有空白位置的二进制数为0.

根据4个二进制位是一个16进制位，可以得到16进制数为：62 03 04.
下面我们来看内存中是不是如此存放的。
内存存放

还真是，那么就说明了我们的存放方式应该是没有问题的。

2.4 位段的应用

位段会在ip网络传输中使用，因为空间越小传递的效率就越高。
ip协议

3. 枚举

枚举顾名思义就是一一列举。
把可能的取值一一列举。
比如我们现实生活中：

一周的周一到周日是有限的7天，可以一一列举。
性别有：男，女，保密，也可以一一列举。
月份有12个月也可以一一列举。

3.1 枚举类型的定义

enum week//星期
{
	Mon,
	Tues,
	Wed,
	Thur,
	Fri,
	Sat,
	Sum
};

enum sex//性别
{
	MALE,
	FEMALE,
	SECRET
};

enum color
{
	RED,
	GREEN,
	BLUE
};

以上定义的enum week``````enum sex``````enum color都是枚举类型。
{}中的内容是枚举类型的可能取值，也叫枚举常量.
这些常量都是有值的，默认从0开始，然后依次递增1，当然在定义时你可以自己赋初值。

enum color
{
	RED = 1,
	GREEN = 2,
	BLUE = 4
};

3.2 枚举的优点

枚举的优点：

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

#incldue <stdio.h>
enum color
{
	RED = 1,
	GREEN = 2,
	BLUE = 4
};
enum color clr = GREEN;
int main()
{
	enum color clr = GREEN;
	printf("%d\n", clr);
	clr = 10;//在c++环境下不行，因为c++的类型检查更严格
	printf("%d\n", clr);
	return 0;
}
//打印结果：
/*
2
10//在c++环境下不行，因为c++的类型检查更严格
*/

4.联合（共用体）

4.1 联合类型的定义

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

#include <stdio.h>
//联合体的声明
union un
{
	char c;
	int i;
};


int main()
{
	//联合变量的定义
	union un u;

	//计算联合体变量的大小
	printf("%d\n", sizeof(u));
	return 0;
}
//打印结果：
//4

4.2 联合的特点

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

#include <stdio.h>

union un
{
	char c;
	int i;
};
int main()
{

	union un u;
	printf("%p\n", &(u.i));
	printf("%p\n", &(u.c));
	return 0;
}
//打印结果：
/*
00EFF6FC
00EFF6FC
*/

根据这个现象，我们可以判断这两个成员就是共用一块空间的。

4.3 联合大小的计算

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

#include <stdio.h>
union un1
{
	char c[5];
	int i;
};
union un2
{
	short c[7];
	int i;
};
int main()
{
	printf("%d\n",sizeof(union un1));
	printf("%d\n",sizeof(union un2));
	return 0;
}
//打印结果：
/*
8
16
*/

4.4 利用联合体判断大小端

#include <stdio.h>

union un
{
	char c;
	int i;
};
int main()
{

	union un u = {u.i = 1};
	if(u.c == 1)
		printf("小端\n");
	else
		printf("大端\n");
	return 0;
}
//打印结果：
//小端