自定义类型-结构体,联合体和枚举-C语言

引言

能看到结构体,说明C语言想必学习的时间也不少了,在之前肯定也学习过基本数据类型,包括整型int,浮点型float等等。可是在日常生活中,想要描述一个事物并没有那么简单。比如,你要描述一本书,关于本书需要描述出书名,定价,以及作者等信息,单靠整数,或者是字符数组都没办法一次性描述清楚,这里就引申出了一种新的可自定义类型——结构体。在一个结构体中,可以定义多种相同或者不同的数据类型,有了结构体,我们便可以根据需要创建自己的数据类型,来描述一些复杂的事物了。同时,本篇还要介绍以下另外两种自定义类型,联合体和枚举。

结构体struct

结构体的创建以及应用

下面写出结构体基本定义

struct tag  //tag为类型名称
{
    member-list;//这里可以定义多行数据类型
}variable-list; //变量创建,可以在此创建结构体变量

 在描述完上方定义后可能你会有些疑惑,但别急,接下来给大家举个例子,现在我们定义一个关于学生的结构体

struct Stu  //这是创建了一个结构体类型
{
	char name[30];
	int age;
	char number[30];
};
struct Stu student={"zhangsan",19,"2003020102"};
//这时在创建结构体类型后运用其创建结构体变量,同时对变量初始化
struct Stu   //这时创建类型的同时创建了三个结构体变量
{
	char name[30];
	int age;
	char number[30];
}student1, student2, student3;

像上方这样, 我们的结构体类型以及变量就创建好了,在创建的同时,还可以进行初始化。下面代码将应用这些变量。以(结构体变量.成员)的形式来访问结构体变量中的元素。

#include 
struct Stu
{
	char name[30];
	int age;
	char number[30];
};
int main()
{
	struct Stu student = { "zhangsan",19,"2001040302" };
	printf("%s\n%d\n%s\n", student.name, student.age, student.number);
	return 0;
}

 自定义类型-结构体,联合体和枚举-C语言_第1张图片

结构体指针形式访问

运用一个指针指向结构体,通过->符号可以直接访问元素,下面是使用样例。

#include 
struct Stu
{
	char name[30];
	int age;
	char number[30];
};
int main()
{
	struct Stu student = { "zhangsan",19,"2001040302" };
	//printf("%s\n%d\n%s\n", student.name, student.age, student.number);
	struct Stu* p;
	p = &student;
	printf("%s\n%d\n%s\n", p->name, p->age, p->number);
	return 0;
}

 自定义类型-结构体,联合体和枚举-C语言_第2张图片

结果依然相同 

结构体传参

现在看下面这样一组代码

#include
struct S
{
	int data[1000];
	int num;
};
void print1(struct S t)
{
	printf("%d %d\n", t.data[1], t.num);
}
void print2(struct S* ps)
{
	printf("%d %d\n", ps->data[1], ps->num);
}
int main()
{
	struct S s = { {1,2,3,4,5},100 };
	print1(s); //传递结构体
	print2(&s);//传递结构体地址
	return 0;
}

自定义类型-结构体,联合体和枚举-C语言_第3张图片

这两种传递的方式都是正确的,但是直接传递结构体的方式却有很大的弊端,就是直接传递传递结构体需要重新开辟一片新的空间,当结构体变量比较大的时候,是极其消耗栈的内存空间的,因此会降低计算机运行效率。但是传递结构体的过程中有时并不想改变其中元素怎么办呢?我们可以给结构体加上const从而保护其中元素,使其在函数中无法通过指针改变结构体中的变量。

#include//此代码很好的在运行函数时保护了结构体变量s
struct S
{
	int data[1000];
	int num;
};
void print2(const struct S* ps)
{
	printf("%d %d\n", ps->data[1], ps->num);
}
int main()
{
	struct S s = { {1,2,3,4,5},100 };
	print2(&s);//传递结构体地址
	return 0;
}

结构体特殊声明

 在结构体声明中,有一些特殊的声明,它们没有类型名,同时没有对应类型,也被称作匿名结构体。这种结构体的变量只能在声明时创建。

#include
struct
{
	int a;
	char b;
}x;
struct
{
	int a;
	char b;
}*p;
int main()
{
	p = &x;
	return 0;
}

当你写出上方这样的代码时,编译器会报错,因为匿名结构体没有对应的类型,就算元素相同,编译器也会将它们当成不同类型。

给结构体类型起名typedef

#include
typedef struct
{
	int a;
	char b;
}S;//此时类型名为S
int main()
{
	S data = { 20,'x' };//此时,可以用类型名S来这样初始化结构体变量
	return 0;
}

结构体的自引用

奇思妙想一下,能否将结构体的元素定义成定义的结构体呢? 像以下这种方式

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

其中data表示的是存储在节点Node中的元素,而next放置的是下一个结构体元素,其中包含的元素同样是一个data和一个Node。这样的想法很美好,但如果将结构体自己定义成自己的元素,那么一层一层套下去,最后导致的结果就是使Node的大小无法被定义,故此方式不可行。 

不过我们可以采取另一种方式,将next定义成一个结构体指针,指向下一个结构体,像下面这样

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

data是节点存储的数据,而next指向下一个结构体的地址,就像一个链条一样将结构体串联了起来,这就是数据结构中链表的内容了,不是本篇内容的重点,不做深究。 

结构体内存对齐

在学习结构体中,不知道你是否考虑过这样的问题,结构体是怎么分配内存的,接下来我们将通过一个代码引入这个问题

#include
struct s1
{
	char c1;
	char c2;
	int i;
};
struct s2
{
	char c1;
	int i;
	char c2;
};
int main()
{
	printf("%zd %zd\n", sizeof(struct s1), sizeof(struct s2));
	return 0;
}

试着猜猜上面代码会打印什么结果呢?

 自定义类型-结构体,联合体和枚举-C语言_第4张图片

看看有没有出乎你的意料?

是的, 由于平台存在内存对齐,故按我们假象所计算的结果与真实编译器实现不同。

下面讲讲对齐规则

对齐规则:

1.结构体的第一个成员对齐到和结构体变量起始位置偏移量为0的地址处;

2.其他成员变量要对齐到某个数字(对齐数,这里的对齐是成员变量元素所占地址大小,比如char的对齐数是1,而int的对齐数为4)的整数倍的地址处。

注意:对齐数=min{编译器默认对齐数,该成员变量大小},即两者的较小值。VS2022的默认对齐数是8,而Linux中gcc没有默认对齐数,即对齐数是成员变量自身大小。

3.结构体总大小为最大对齐数(结构体中每个成员变量都有一个对齐数,所有对齐数中最大的)整数倍。

4. 如果嵌套了结构体的情况,嵌套的结构体成员对齐到自己的成员中最大对齐数的整数倍处,结构体的整体大小就是所有最大对齐数(含嵌套结构体中成员的对齐数)的整数倍。

根据上述的规则,我们可以再来看看代码,跟具规则来计算开辟的空间

先来分析第一个,首先char c1,由对齐规则1,可知开辟到0地址处,然后到了char c2,char对齐到1的整数倍,所以开辟在1地址处,当开始开辟int类型i的内存时,由于i的对齐数是4,所以要对到4的整数倍上,所以最后在4的位置开辟空间,而地址2,3的内存就被浪费了,所以是空。开辟结束时所占内存大小为8,刚好是最大对齐数4的整数倍,所以最终结构体s1所占内存为8。结果见下图左方。

再来分析第二个结构体,首先还是开辟char c1在0处,然后开辟int类型i的空间,因为要与int所占内存大小4,对齐数为4,所以在4处开辟空间,1,2,3被浪费。再开辟c2,其对齐数为1,所以在8处开辟空间,在开辟完之后所占内存为9,不是最大对齐数的整数倍,所以还要再多开辟三个空间,9,10,11被浪费。最后开辟空间数为12。见下图右方。

 自定义类型-结构体,联合体和枚举-C语言_第5张图片

到了这里,大家可能又有了一些疑问,为社么会存在内存对齐?下面是一些参考资料给出的解答

为什么存在内存对齐?

1.平台原因(移植原因):

不是所有的硬件平台都能访问任意地址上的任意数据;某些硬件平台只能从某些特定地址处取某些特定的数据,否则抛出硬件异常

2.性能原因:

数据结构(尤其是栈)应该尽可能地在自然边界上对齐。原因在于,为了访问未对齐的内存,处理器需要做两次内存访问;而对齐的内存访问仅需一次。假设一个处理器总是从内存中取8个字节,则地址必须是8的倍数。如果我们能保证将所有的double类型数据的地址都对齐为8的倍数,那么就可以用一个内存操作来读写值了。否则,我们可能需要执行两次内存访问,因为对象可能被分别放在8个字节内存块中。

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

修改默认对齐数

#include
#pragma pack(1)//修改默认对齐数为1
struct S
{
    char c1;
    char c2;
    int i;
};//此时sizeof(struct S)的值为6
#pragma pack()//取消设置的对齐数,还原为默认对齐数

结构体实现位段 

C语言中,位段是一种数据结构,允许你为结构体中的成员分配一个特定数量的位(bit),而不是分配完整的字节。这在需要精确控制内存分布或减少内存占用时很有用,比如硬件访问和网络协议设计。对于字段的声明与结构体类似,但也有不同:位段通过在结构体定义中为成员后添加一个冒号和位数(比特位)来创建的,例如:

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

位段的内存分配

1.位段的成员可以是int,unsigned int,signed int或者是char类型

2.空间按照四个字节(int)/一个字节(char)的方式来开辟的

3.位段涉及很多不确定因素,位段是不跨平台的,注重可移植的程序应该避免使用位段 

位段的成员是顺序放置的,但当当前存储单元没有足够的空间容纳下一个位段时,编译器可能(会不会跳转取决于编译器)会跳转到下一个存储单元。这可能导致在存储单元有未使用的位。

编译器可能在位段的末尾添加填充,现在让我们假设一下VS2022的字段分配方式

现在有以下代码

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

位段中的成员在内存中从左向右,还是从右向左尚未定义。

假设为从右向左分配,char中首先为8个比特位,首先a占三个比特位,我们赋a的值为10,二进制为1010,经三个比特位截断得010,也就是二

 

当赋值b的时候,b占4个比特位,赋值b为12,二进制1100,刚好取四位1100 

下一个c占5个比特位,由于无法放下,跳转下一个位段放置的值为3,二进制00011

 

最后d占4个比特位,在第二个位段放入会超范围条赋值跳到下一个位段,4二进制0100放入,最终结果为下图

我们断点调试一下,验证一下结果,先取出结构体s的地址,开始内存中存的都是0,当走过s.a赋值语句时,内存中的值发生了变化

自定义类型-结构体,联合体和枚举-C语言_第6张图片

当运行过s.b后 

自定义类型-结构体,联合体和枚举-C语言_第7张图片 

运行s.c后 

自定义类型-结构体,联合体和枚举-C语言_第8张图片 

运行完s.d后 

 自定义类型-结构体,联合体和枚举-C语言_第9张图片

 经过调试验证,得到最终结果,假设正确(注意:在调试时显示的值都是以四个比特位的形式显示的,故显示的值不一定等于存入的值)

十六进制0x 62 03 04的二进制为:01110010 000000110 00000100

位段的跨平台问题

位段的内存布局:不同的编译器可能会以不同的顺序排列位段。有些编译器可能会按照声明的顺序排列位段,而其他编译器可能会重新排序以优化空间或访问率

位段中的存储单元:位段通常储存在整型存储单元中,但不同的编译器可能会选择不同的类型作为存储单元

C中位段内存从左向右和从右向左是没有确切定义的,端序影响在大端和小端中,位段的物理存储顺序可能不同

注:由于bit位没有地址,所以位段的几个成员公用一个字节,这样有些成员的起始位置并不是某些字节的起始位置,那么这些位置是没有地址的,所以无法通过取地址的方式为其赋值

struct S
{
	char a : 3;
	char b : 4;
	char c : 5;
	char d : 4;
};
int main()
{
	struct S s = { 0 };
	//scanf("%d",&s.a);<---wrong,结构体位段不可取地址
	//以下赋值方式均正确
    s.a = 10;
	s.b = 12;
	s.c = 3;
	s.d = 4;
}

联合体union

什么是联合体

与结构体很相似,联合体也是由一个或多个成员构成,这些成员可以是不同的类型,来看看下面这段代码会打印什么

#include
union u
{
	char c;
	int num;
};
int main()
{
	union u uu;
	printf("%zd\n", sizeof(uu));
	printf("%p\n", &uu);
	printf("%p\n", &(uu.c));
	printf("%p\n", &(uu.num));
	return 0;
}

 自定义类型-结构体,联合体和枚举-C语言_第10张图片

可以发现,uu占用的空间只有4个字节,而且后面三个地址是相同的,这意味着什么呢?uu.c和uu.num占用的空间在相同的位置,共用一块空间,当一个元素被赋值时,另一个元素的值会被覆盖。因为联合体的这种特性,我们还叫他共用体。 

联合体与共用体比较

struct s //结构体
{
	char c;
	int i;
};
union u  //联合体
{
	char c;
	int i;
};

自定义类型-结构体,联合体和枚举-C语言_第11张图片

上图中粉色的是被浪费的空间 

联合体占用内存

关于占用内存这里要严谨一点,很多教课书和课程里都说联合体的大小是最大成员的大小,实际上这样说是错的,在联合体中也存在和结构体一样的对齐数,当最大元素所需的的空间不是对齐数的倍数时,会自动将其矫正为对齐数倍数,见下图,附上代码

#include
union u
{
	char c[5];
	int i;
};
int main()
{
	union u uu;
	printf("%zd\n", sizeof(uu));
	return 0;
}

自定义类型-结构体,联合体和枚举-C语言_第12张图片

联合体的应用

也许你会问计算机内存这么大,联合体节省那一点空间真的有必要吗,但是联合体并不主要用于计算机中,在内存极其宝贵的硬件中,节省这样一些空间是很有必要的。

大小端判断(共用体版)

在上一篇博客讲到计算机内存时,曾讲过一段判断大小端的代码,链接放这里,可以去看,里面还有讲解大小端是什么。数据在内存中的存储-CSDN博客

今天我们要用联合体编写一段代码来判断大小端,见下代码

#include
//n和s共用一块空间
//当给n赋值后用s可以随意取每个字节上的元素
int check_sys()
{
	union
	{
		char c;
		int i;
	}u;
	u.i = 1;
	return u.c;
}
int main()
{
	if (check_sys()) {
		printf("小端\n");
	}
	else
		printf("大端\n");
	return 0;
}

自定义类型-结构体,联合体和枚举-C语言_第13张图片

这样的代码是不是让人眼前一亮,当一个人对代码有很强的掌控力时,打代码便成了一种艺术。

枚举enum

定义枚举

通过关键字enum定义。eg:

enum Sex
{
	//这里列举枚举类型 性别 的可能取值
	MALE,  //男
	FEMALE, //女
	SECRET  //保密
};

默认情况下,枚举的第一个成员的值是0,后续成员值依次递增,但同时我们可以给其指定值:

enum Sex
{
	//这里列举枚举类型 性别 的可能取值
	MALE = 3,  //男
	FEMALE = 5, //女
	SECRET = 9  //保密
};

枚举和#define定义常量很像,枚举变量里定义的值是符号常量。

故可以这样使用

#include
enum Sex
{
	//这里列举枚举类型 性别 的可能取值
	MALE,  //男
	FEMALE, //女
	SECRET  //保密
};
int main()
{
	enum Sex zhangsan = MALE;
	if (zhangsan == MALE) {
		printf("张三是男的\n");
	}
	else printf("张三是女的\n");
	return 0;
}

 自定义类型-结构体,联合体和枚举-C语言_第14张图片

枚举的优点

1.代码可读性:枚举常量的使用可以提高代码的可读性和可维护性

2.类型安全:枚举提供了一个类型安全的方法来表示一组整数值

3.调试方便:调试时,枚举变量可同时显示其字符常量和其值,便于观察

结语

 到了这里,结构体,联合体和枚举就介绍完了,一篇博客费时费力,画图也是一大难点,看在我这么辛辛苦苦写博客的份上,给个小小的赞不过分吧。如果感觉这篇博客对你有帮助的话,还请给个小小的赞再走啊!比心---♥

你可能感兴趣的:(c语言,开发语言)