C语言——自定义类型（结构体、枚举、联合）

Magic--Y

已于 2022-07-18 23:28:02 修改

阅读量235

点赞数

分类专栏： C语言文章标签： c语言开发语言后端

于 2022-02-12 11:17:38 首次发布

本文链接：https://blog.csdn.net/ygy555/article/details/122877885

版权

C语言专栏收录该内容

14 篇文章 0 订阅

订阅专栏

C语言自定义结构体类型

结构体

数组是一组相同类型的元素的集合
结构体也是一些值的集合，结构的每个成员可以是不同的类型结构体的声明

结构体的声明

struct STU
{
	char name[20];
	int age;
	char id[10];
};

声明结构体的一般的形式是：
struct 结构体名
{
结构体成员;
}
struct是结构体关键字，STU是结构体名，struct STU是个类型，即结构体类型，类似于int,float等，name、age、id是结构体成员变量名
struct STU a;//创建了结构体变量a
int a;//创建了整型变量a

结构体的特殊声明

//匿名结构体类型，只能使用一次
struct
{
	char name[20];
	int age;
	char id[10];
}a;

这种类型的结构体只能使用一次直接创建全局变量，如代码中的s，在main中无法创建结构体变量

结构体的自引用

struct node
{
	int data;//存放数值，数据域
	//struct node next;//错误
	struct node* next;//存放下一个节点的地址，指针域，自己找到同类型的下一个节点
};

1.结构体自引用就是一部分存放数据，另一部分存放结构体类型的指针变量，方便找到下一个结构体
2. 如果存放的是相同结构体类型的变量，需要的内存空间将无限大，无法分配内存空间，无限套娃

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

struct STU
{
	char name[20];
	int age;
	char id[10];
}a = {"zhangsan",20,"12345"};//全局变量，声明类型的同时定义并初始化变量a

typedef struct stu
{
	char name[10];
	int age;
	double score;
}S1;//将结构体类型struct stu重新定义为S1结构体类型

int main()
{
	struct STU b = { "lisi",22,"23456" };
	//局部结构体变量b，并且给b初始化
	S1 s;//创建变量
	S1 s1 = { "zhangsan",18,80.0 };
	return 0;
}

结构体内存对齐

#include <stdio.h>
struct S1
{
	char a;
	char b;
	int c;
};
int main()
{
	struct S1 s = { 0 };
	printf("%d\n", sizeof(s));//结果为8
	return 0;
}

在这里插入图片描述

1.a是字符型变量，占1个字节，在偏移量为0的地方保存
2.b也是字符型变量，占1个字节，它的对齐数是1和8的最小值1，所以它在偏移量为1的地方保存
3.c是整型变量，占4个字节，它的对齐数是4和8的最小值4，所以它在偏移量为4的倍数的地方保存，2，3均不是4的倍数，所以c在偏移量为4的地方保存，由于c占4个字节，故占用了偏移量为4~7的内存空间中
4.结构体的总的最大对齐数是1，1，4的最大值4，故总的大小应该是4的倍数，0~7共8个字节，是4的倍数，故结构体的总大小是8

同样的代码来交换下位置，所占内存数不同

#include <stdio.h>
struct S1
{
	char a;
	int c;
	char b;
};
int main()
{
	struct S1 s = { 0 };
	printf("%d\n", sizeof(s));//12
	return 0;
}

在这里插入图片描述

1.与第一个代码类似，a放在偏移量为0的位置
2.c是整型占4个字节，对齐数是8和4的最小值4，放在偏移量是4的倍数的地方，故放在偏移量是4的位置，依次占用4 5 6 7
3.b占一个字节，对齐数是8和1的最小值1，故放在偏移量是8的位置
4.a b c中的最大对齐数是4，故结构体总的大小是4的倍数，由于0~8共9个字节不是4的倍数，所以要继续向下开辟空间到11， 0 ~11共12字节是4的倍数，所以结构体总的大小是12

a,c,b的偏移量是0，4，8，我们通过代码验证

#include <stdio.h>
#include <stddef.h>//与offsetof相关的头文件
struct S1
{
	char a;
	int c;
	char b;
};
int main()
{
	struct S1 s = { 0 };
	printf("%d\n", sizeof(s));//12
	printf("%d\n", offsetof(struct S1, a));//0
	printf("%d\n", offsetof(struct S1, c));//4
	printf("%d\n", offsetof(struct S1, b));//8
    //offsetof 宏，用来计算结构体成员的偏移量
	return 0;
}

输出：
在这里插入图片描述

1.结构在内存中按照结构体对齐的方式存储
2.结构体的对齐规则
（1）第一个结构体成员在与结构体变量偏移量为0的地址处
（2）其他结构体成员要对齐到某个数字（对齐数）的整数倍的地址处
对齐数=编译器默认的对齐数（vs是8）与该成员大小的较小值，比如整型的大小是4个字节，小于8，所以它的对齐数是4，就要对齐到4的整数倍的地方
结构体的总大小为最大对齐数（每个成员变量都有一个对齐数）的整数倍
（3）若嵌套了结构体，嵌套的结构体对齐到自己的最大对齐数的的整数倍处，结构体的整体大小就是所有最大对齐数（含嵌套结构体的对齐数）的整数倍

来看嵌套结构体的情况

#include <stdio.h>
struct S1
{
	char a;
	char b;
	int c;
};
struct S2
{
	char a;
	struct S1 s;
	double c;
};
int main()
{
	struct S2 s = { 0 };
	printf("%d\n", sizeof(s));//24
	return 0;
}

在这里插入图片描述

1.a占一个字节打大小，放在偏移量是0的位置
2.结构体S1的占8个字节，它的最大最大对齐数是4，故放在偏移量是4的整数倍的地方，1~3不是4的倍数，所以放在4 ~11的位置
c是double类型，占8个字节，对齐数是8，所以放在8的整数倍的地方，所以放在偏移量16~23的位置
结构体中对齐数是1 4 8中的最大值8，所以总的大小是8的倍数，0~23共24个字节是8的倍数，最后总的大小是24

总结：
1.求结构体的大小，其类型就是所占的大小，char a[10]是1个字节
2.结构体第一个成员都放在偏移量为0的位置
3.往后的成员需要计算对齐数,根据对齐数的规则计算
4.根据对齐数，将成员放在对齐数的整数倍的地方，求出最大对齐数
5.结构体总的大小是最大对齐数的整数倍，注意从0开始算大小

存在内对齐的原因

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

在32位机器上，可以一次操作4个字节的数据，如果内存不对齐，需要读0 1 2 3 和 4 5 6 7 两次才能读全b,如果内存对齐，只需读4 5 6 7 一次就可以读全b
总之就是拿空间来换取时间,，所以在对设计结构体成员时，尽量让占用空间小的集中在一起

修改默认对齐数

#include <stdio.h>
#pragma pack(1)//设置默认对齐数为1
struct S1
{
	char a;
	char b;
	int c;
};
#pragma pack()//取消设置的默认对齐数，还原为默认

int main()
{

	printf("%d\n", sizeof(struct S1));//6
	return 0;
}

输出结果:
在这里插入图片描述

1.使用#pragma可以修改默认对齐方式，使用方法是：
#pragma(要修改的对齐数)，要修改的对齐数一般是2^n
2.#pragma pack()是取消修改默认对齐数，还原为默认值8
3.上述代码在默认对齐数下是8个字节，修改后是6个字节

结构体传参

#include <stdio.h>

typedef struct stu 
{
	char name[10];
	int age;
}SS;

//结构体传参
void Print1(SS s) 
{
	printf("%d\n", s.age);//用.访问
}

//结构体地址传参
void Print2(SS* ps) 
{
	printf("%d\n", ps->age);//用->访问
}

int main()
{
	SS s1 = { "zhangsan",18 };
	Print1(s1);//传结构体
	Print2(&s1); //传地址
	return 0;
}

输出结果：

1.结构体传参可以传结构体，形参用结构体类型接收，也可以传结构体类型变量的地址，形参用结构体指针接收
2.结构体成员的访问：
（1）使用 . 操作符进行访问，结构体变量.结构体成员名
（2）使用->操作符进行访问，结构体指针变量->结构体成员名
3.上述代码最好用Print2，因为函数传参的时候，参数是需要压栈，会有时间和空间上的系统开销。如果传递一个结构体对象的时候，结构体过大，参数压栈的的系统开销比较大，所以会导致性能的下降。

位段

位段的声明

与结构体类似，但也有不同

位段的成员必须是 int、unsigned int 或signed int或char
位段的成员名后边有一个冒号和一个数字
位段的空间上是按照需要以4个字节（ int ）或者1个字节（ char ）的方式来开辟
一般情况下位段都是统一类型的
冒号后的数字大小不能超过其类型
位段涉及很多不确定因素，位段是不跨平台的，注重可移植的程序应该避免使用位段

#include <stdio.h>

struct S1
{
    //4byte
	int a : 2;//2个bit位，00 01 10 11,四个数值，所以int a的大小是0~3
	int b : 5;//5个bit
	int c : 10;//10个bit
	//4byte
	int d : 30;//30个bit
};
struct S2
{
	int a;
	int b;
	int c;
	int d;
};

int main()
{

	printf("%d\n", sizeof(struct S1));//8个字节
	printf("%d\n", sizeof(struct S2));//16个字节
	return 0;
}

输出结果:

S1共47bit位，用6byte可以用来储存，但实际结果是8byte?
位段第一个成员首先开辟4个byte的空间，共32bit，第一个成员占2bit，第二个成员占5个bit，第三个成员占10个bit，还剩下15bit，由于不够d使用，所以再开辟4个byte使用，一共8个byte

#include <stdio.h>

struct S1
{

	char a : 2;
	char b : 5;
	char c : 4;
	char d : 5;
};


int main()
{

	struct S1 s = { 0 };//00010001 00000011 00000001 11 03 01
	printf("%d\n",sizeof(s));
	s.a = 5;//0101
	s.b = 4;//0100
	s.c = 3;//0011
	s.d = 1;//0001
	return 0;
}

输出结果:
在这里插入图片描述

1.由于成员是char类型的变量，所以先开辟1个字节的空间，而a,b一共占7个bit，c占4个bit，故再开辟一个字节的空间，d占5个bit,需要再开辟一个字节的空间，共3个字节
2.给成员赋值时，a是0101,由于a只拥有2个bit，所以前面舍去，只取01，b,c,d的空间够用，所以不用截取，最后在VS2019内存中显示11 03 01
3.位段开辟空间是根据成员的类型开辟的，char是1个字节，int是4个字节，如果不够会继续开辟这种类型的空间

位段的跨平台问题

int 位段被当成有符号数还是无符号数是不确定的
位段中最大位的数目不能确定（16位机器最大16，32位机器最大32，写成27，在16位机器会出问题
位段中的成员在内存中从左向右分配，还是从右向左分配标准尚未定义
当一个结构包含两个位段，第二个位段成员比较大，无法容纳于第一个位段剩余的位时，是舍弃剩余的位还是利用，这是不确定的,跟结构相比，位段可以达到同样的效果，但是可以很好的节省空间，但是有跨平台的问题存在

枚举

枚举类型就是一种类型，枚举就是可以一一列举出来，是有限的

枚举类型的定义

#include <stdio.h>
enum color//也可以对其赋初值，如RED=2，后面会依次递增1，也可以每个常量进行单独赋值
{
	RED,
	GREEN,
	BLUE
};
int main()
{
	enum color col = RED;//只能拿枚举常量给枚举变量赋值，才不会出现类型的差异
	//RED=3;error,常量不允许改变其值

	printf("%d\n", RED);//0
	printf("%d\n", GREEN);//1
	printf("%d\n", BLUE);//2
	return 0;
}

输出结果：
在这里插入图片描述

1.枚举是个类型，类似于int,float等
enum color col;//定义枚举类型变量col
int col;//定义整型变量/b>
2.枚举类型默认是有值的，从0开始依次增加1，当然也可以在定义的时候赋值，但是初始化或使用时不能赋其他值，只能赋枚举定义的如RED等

枚举的优点

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

联合

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

联合体类型定义和大小

#include <stdio.h>
union UN1
{
	char a;
	int b;
};
union UN2
{
	char a[5];//对齐数1  共5个字节不是最大对齐数4的整数倍，8是整数倍
	int b;//对齐数4
};
int main()
{
    union UN1 u1;
	printf("%d\n", sizeof(union UN1));//4
	printf("%d", sizeof(union UN2));//8
	return 0;
}

输出结果：
在这里插入图片描述

1.union是联合体的关键字
2.定义枚举类型变量union UN1 u1;
类似于定义整型变量int u1;
3.联合的大小至少是最大成员的大小
4.当最大成员大小不是最大对齐数的整数倍的时候，就要对齐到最大对齐数的整数倍，UN2中是最大对齐数4的倍数8

联合体的特点

#include <stdio.h>
union UN1
{
	char a;
	int b;
};

int main()
{
	union UN1 u1;
	printf("%p\n", &u1);
	printf("%p\n", &(u1.a));
	printf("%p\n", &(u1.b));
	return 0;
}

输出结果：
在这里插入图片描述

1.联合体成员的地址是共用的，说明他们使用同一块内存空间
2.每次只能访问一个成员，类似于共享汽车，你使用的时候，别人就不能用

根据这个特性可以求大小端

#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>

int check_sys()
{
	union UN//只为这个函数准备UN可以省略，匿名联合体
	{
		char a;
		int b;
	}u;

	u.b = 1; 

	return u.a; 
}
int main()
{
	if (1 == check_sys())
	{
		printf("小端\n");
	}
	else
	{
		printf("大端\n");
	}

	return 0;
}

输出结果：
在这里插入图片描述

上面的图片是开辟了四个字节的空间，00000001 00000000 00000000 00000000，用16进制显示是01 00 00 00，由于a和b共用一块内存空间，a是char类型，b是int，所以将b赋值为1，而a只能访问一个一个字节，如果返回1则证明是小端，反之大端

Magic--Y

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
C语言——自定义类型（结构体、枚举、联合）

自定义类型结构体的声明结构体的特殊声明结构体变量的定义和初始化结构体内存结构体的对齐规则同样的代码来交换下位置，所占内存数不同来看嵌套结构体的情况存在内对齐的原因我们也可以自己修改对齐数位段@[toc]位段的声明与结构体类似，但也有不同位段的跨平台问题跟结构相比，位段可以达到同样的效果，但是可以很好的节省空间，但是有跨平台的问题存在枚举类型就是一种类型枚举类型的定义使用枚举的优点联合也是一种特殊的自定义类型，这种类型定义的变量也包含一系列的成员，特征是这些成员公用同一块空间（所
复制链接

扫一扫