C语言自定义类型+结构体+枚举+位段+联合+对齐数

文章目录

目录

文章目录

前言

二、结构体

1.结构体的声名

2.特殊结构体声名

4.结构体自引用

5.结构体变量的声名

6.结构体内存对齐

7.修改结构体对齐数

8.结构体传参

二、位段

2.1 什么是位段？

2.2 位段的内存分配

三、枚举

3.1 枚举类型的定义

3.2枚举的使用

3.3 枚举的优点

四、联合（共用体）

4.1 联合类型的定义

4.2联合体实现计算计算机大端存储或者小端存储

4.3 联合大小的计算

总结

前言

在我们今后的编程生活中，我们不仅只运用c语言内置的数据类型，我们还有很多类型需要自我编写，结构体就可以帮我们实现这个想法。

一、自定义类型是什么？

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

二、结构体

1.结构体的声名

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

我们在自己编写一个结构的时候需要需要运行结构体专有的关键字  struct ；用来声名一个结构体的。

接下来代码介绍

struct stu {
	char name[20];//结构体成员变量
	char tele[30];//电话
	char sex[10];//性别
	int age;//年龄
};
int main()
{
   struct stu person={"feima","2301_80687320","nan",12};//创建一个结构体变量，并且进行赋值
   
   return 0;
}

这就是一个结构体的声名；必须运用struct这个关键字；

2.特殊结构体声名

在结构体声名的时候可以用来匿名声名结构体；

在创建结构体时可以省略stu这个标签名在结构体最后直接加变量名；

代码如下（示例）：

//匿名结构体类型
struct  //在特殊结构体声名过程中我们省略了此处的标签名
{
 int a;
 char b;
 float c;
}y;//x={.a=10,.b='w',.c=1.00};//在最后加入了变量名,思考x这样写正确嘛？
struct
{
 int a;
 char b;
 float c;
}a[20], *p;

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

2 我们学习了数据类型知道变量需要赋值，那么我们能否在创建结构体变量时赋值呢？x的写法正确吗？

答 1 在匿名结构体中，匿名只能用一次，当我们对x这个变量取地址后，它就会销毁，我们将此赋值个p在找回去的时候这块空间可能储存了别的数据进来；

答2 这样写是可以的当我们在主函数中再次赋值也是可以的，它等价于在主函数中赋值；

4.结构体自引用

在结构中包含一个类型为该结构本身的成员

当我们想将一个结构体像数组一样连接起来，那么我们一定需要结构体的自引用；

我们想要找到和自己结构体相同的下一个节点，我们需要应用结构体中包含指针的形式，其他类型找不到；

代码如下（示例）：

//代码1
struct Node
{
 int data;
 struct Node next;
};
//可行否？

//代码2
struct Node
{
 int data;
 struct Node* next;
};

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

上面两种声名方式，代码一是声名一个Node 类型中有一个int 类型 还有一个自身类型，在赋值时就会先给data赋值，然后再次调用Node再次赋值，就会形成一个死循环，就不能实现像数组一样的地址连接；

代码2 先声名一个data的整型，然后在声名一个Node类型的指针next；在我们赋值时就会先给data赋值然后调用Node类型的指针，计算机可以通过next这个Node类型指针找到下一个于data类型相同的下一个节点；

当我们想给Node重新起名byd我们需要用到typedef；当我们重新取名的时候不可以省去Node，因为下面用了Node*这名；在此等价于先有鸡还是先有蛋。

正确重新取名为代码3.

5.结构体变量的声名

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

struct Point
{
 int x;
 int y;
}p1; //声明类型的同时定义变量p1
struct Point p2; //定义结构体变量p2
//初始化：定义变量的同时赋初值。
struct Point p3 = {x, y};
struct Stu        //类型声明
{
 char name[15];//名字
 int age;      //年龄
};
struct Stu s = {"zhangsan", 20};//初始化
struct Node
{
 int data;
 struct Point p;
 struct Node* next;
}n1 = {10, {4,5}, NULL}; //结构体嵌套初始化
struct Node n2 = {20, {5, 6}, NULL};//结构体嵌套初始化

在结构体声名的后面顺带初始化这是一个全局变量；

在主函数中初始化是局部变量；

6.结构体内存对齐

我们已经掌握了结构体的基本使用了。

现在我们深入讨论一个问题：计算结构体的大小。

首先得掌握结构体的对齐规则：

1. 第一个成员在与结构体变量偏移量为0的地址处。

2. 其他成员变量要对齐到某个数字（对齐数）的整数倍的地址处。

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

VS中默认的值为8 Linux中没有默认对齐数，对齐数就是成员自身的大小

3. 结构体总大小为最大对齐数（每个成员变量都有一个对齐数）的整数倍。

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

有了对齐规则，我们练习一下

代码如下（示例）：

//练习1
struct S1
{
 char c1;
 int i;
 char c2;
};
printf("%d\n", sizeof(struct S1));
//练习2
struct S2
{
 char c1;
 char c2;
 int i;
};
printf("%d\n", sizeof(struct S2));
//练习3
struct S3
{
 double d;
 char c;
 int i;
};
printf("%d\n", sizeof(struct S3));
//练习4-结构体嵌套问题
struct S4
{
 char c1;
 struct S3 s3;
 double d;
};

1.我们开始从0开始对齐放入c1占一个字节 ；

2.然后方int i，占四个字节，对齐数是4，我们就要从4的倍数开始存放，4刚好是对齐数4的倍数，所以我们从4的位置存放i，占4个字节；

3.char c2对齐数是1 ，8是c2对齐数的整数倍，所以在8的位置放，c2；

4.结构体总大小为最大对齐数的整数倍，最大对齐数是int i为4，8是4的倍数，所以练习1的总大小为8；

做一做

练习2，3，4；如果有问题可以私信博主；

为什么存在内存对齐? 大部分的参考资料都是如是说的：

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

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

总体来说

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

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

7.修改结构体对齐数

之前我们见过了 #pragma 这个预处理指令，这里我们再次使用，可以改变我们的默认对齐数。

#pragma pack(8)//设置默认对齐数为8
struct S1
{
 char c1;
 int i;
 char c2;
};
#pragma()//修改为默认对齐数

不做过多介绍。

8.结构体传参

我们之前学过数组传参，我们知道，当我串一个数组到一个函数中的时候我们可以直接串一个数组到函数，函数创建一个数组接受；还可以传递数组的首元素地址到函数，函数创建一个指针接受，通过地址找到原数组，不需要在开辟一块空间。

在结构体传参也是一样的；

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中就需要在开辟一块空间储存s，这样使空间浪费，当s所占据空间特别大时，会使栈溢出；

因此我们可以传递s的地址到print2，然后用指针接受，如果害怕出错将s修改，我们可以创建一个不可修改指针，用const修饰即可；

二、位段

2.1 什么是位段？

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

1.位段的成员必须是 int、unsigned int 或signed int 。

2.位段的成员名后边有一个冒号和一个数字。

2.2 位段的内存分配

 1.位段的空间上是按照需要以4个字节（ int ）或者1个字节（ char ）的方式来开辟的。

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

代码如下（示例）：

struct A
{
 int _a:2;//二进制位//两个bit位
 int _b:5;//5bit
 int _c:10;//10bit
 int _d:30;//30bit
};

A就是一个位段类型。

int 原本为4个字节，32bit，运用位段以后，_a变为两个比特位，只能存储00 01 10 11这几个二进制数；

以此类推_b _c _d;

三、枚举

在前面我们学习中就遇到了枚举；

枚举顾名思义就是一一列举。

把可能的取值一一列举。

比如我们现实生活中： 一周的星期一到星期日是有限的7天，可以一一列举。

3.1 枚举类型的定义

在结构体中，我们运用枚举就需要用到枚举的关键字enum；

代码如下（示例）：

enum Day//星期
{
 Mon,
 Tues,
 Wed,
 Thur,
 Fri,
 Sat,
 Sun
};
enum Sex//性别
{
 MALE,
 FEMALE,
 SECRET
}；
enum Color//颜色
{
 RED,
 GREEN,
 BLUE
};

以上定义的 enum Day ， enum Sex ， enum Color 都是枚举类型。 {}中的内容是枚举类型的可能取值，也叫 枚举常量 。 这些可能取值都是有值的，默认从0开始，依次递增1，当然在声明枚举类型的时候也可以赋初值。

3.2枚举的使用

enum Color//颜色
{
 RED=1,
 GREEN=2,
 BLUE=4
};
int main()

{
	enum Color c = green;//枚举有类型检查的 c为Color类型，为枚举类型
	int a = c;//c为green 为1 1为整型，赋值给a
	printf("%d\n", a);//1
	return 0;
}

3.3 枚举的优点

为什么使用枚举？

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

枚举的优点：

1. 增加代码的可读性和可维护性

2. 和#define定义的标识符比较枚举有类型检查，更加严谨。

3. 便于调试

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

四、联合（共用体）

运用联合体就需要用到关键字union

4.1 联合类型的定义

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

代码如下（示例）：

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

//联合（共同体）关键字union
//union Un
//{
//	char c;
//	int i;
//};
//int main()
//{
//	union Un un;
//	printf("%d\n", sizeof(union Un));
//	printf("%p\n", &(un.c));
//	printf("%p\n", &(un.i));
//	printf("%p\n", &un);
//	return 0;
//}是同一个地址

4.2联合体实现计算计算机大端存储或者小端存储

大端和小端：小端是从大地址往小地址存储；如储存1 ，为01 00 00 00

/大端相反，为00 00 00 01；

在4.1中我们知道了结构体内的各个类型都是在同一个地址中存储；因此我们可以计算机的存储方式；当我们定义一个整型1；在定义一个char类型c放在联合体中，当我们是小端存储，c和int类型的01都在同一个位置上；

代码理解如下

用联合体判断大端小段
int che__sys()
{
	union 
	{
		int i;
		char c;
	}un = { .i = 1 };
	return un.c;
}
int main()
{
	
	int ret = che_sys();
	if (ret == 1)
		printf("大端\n");
	else
		printf("小端\n");
	return 0; 
}

4.3 联合大小的计算

它也遵循结构体的计算大小的规则

代码如下（示例）：

union Un1
{
 char c[5];
 int i;
};
union Un2
{
 short c[7];
 int i;
};
//下面输出的结果是什么？
printf("%d\n", sizeof(union Un1));
printf("%d\n", sizeof(union Un2));

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

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

总结

1.结构体需要用struct关键字声名

2.枚举需要用enum声名

3联合体需要用union声名

4联合体体大小计算规律

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

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

5结构体大小计算规律

    1. 第一个成员在与结构体变量偏移量为0的地址处。

    2. 其他成员变量要对齐到某个数字（对齐数）的整数倍的地址处。

    3. 结构体总大小为最大对齐数（每个成员变量都有一个对齐数）的整数倍。

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