【编程之路（014）】自定义类型：结构体，枚举，联合（C语言实现）

目录

结构体

结构体类型的声明：

结构体内存对齐：

结构体传参：

位段：

枚举

枚举的定义：

枚举的优点：

枚举的使用：

联合（共用体）

联合类型的定义：

联合的特点：

联合大小的计算：

---

结构体

结构体类型的声明：

结构体定义：因为生活中不只有简单的整形，浮点型等等，所以就有了结构这一说。结构是一些值的集合，这些值称为成员变量。结构的每个成员可以是不同类型的变量。

结构的声明：

//这里的Stu是标签，通常是命名成与结构体相关的名字
struct Stu
{
	char name[10];//成员变量
	int age;//成员变量
	char id[20];//成员变量
};//注意这里的分号不能丢

特殊声明：

struct
{
	char name[10];
	int age;
	char id[20];
}stu;
//标签省略之后，后面必须要有一个变量
//如果不定义变量，往后也无法使用该结构体


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

p = &stu;
//虽然这两个结构相同，但是也非相同的类型，所以不能这样
//只能在声明的时候提前把与该结构体有关的变量都写好

结构体的自引用：

struct Node
{
	int data;
	struct Node* next;
	//表示指向相同类型的结构体
	//自引用只能是指针的形式，如上
	//写成struct Node next;就会是一种无限套娃的类型，是错误的
};

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

在特殊声明中其实也用到了结构体变量的定义。

其实有了结构体声明，就相当于我们有了这个类型，就比如我们原本就有int类型一样。类型有了，使用该类型是，自然而然的就要定义该类型的变量，在初始化变量。

变量定义：

//定义结构体类型的变量s1
struct Stu
{
	char name[10];
	int age;
	char id[20];
}s1;

//定义结构体类型的变量s2
struct Stu s2;

初始化：

//初始化结构体类型的变量s1
struct Stu
{
	char name[10];
	int age;
	char id[20];
}s1 = { "xiaoming",20,"20220711" };

//初始化结构体类型的变量s2
struct Stu s2 = { "xiaoming",20,"20220711" };

结构体嵌套初始化：

struct Point
{
	int x;
	int y;
};

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

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

小结：结构体既可以单独声明，也可以同时定义变量，还可以同时给变量赋值。

另外，结构体的声明通常在头文件中。如果在那里定义变量，那就是全局变量。

---

结构体内存对齐：

规则：

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

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

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

VS中默认的值为8（只有vs才有对齐数，其他编译器都没有）

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

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

体大小就是所有最大对齐数（含嵌套结构体的对齐数）的整数倍。

上面的规则需要配图才能更加直观明了。

计算左边结构体大小：

 

struct S1
{
	char c1;
	int i;
	char c2;
}s1;

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

#include<stdio.h>

int main()
{
	printf("%d %d\n", sizeof(s1), sizeof(s2));

	return 0;
}

与分析结果一致

接下来分析有结构体嵌套的怎么算

struct S1
{
	char c1;
	int i;
	char c2;
}s1;

struct S2
{
	char c1;
	struct S1 s1;
	int i;
}s2;

#include<stdio.h>

int main()
{
	printf("%d %d\n", sizeof(s1), sizeof(s2));

	return 0;
}

 

 为什么存在内存对齐?

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

不是所有的硬件平台都能访问任意地址上的任意数据的；某些硬件平台只能在某些地址处取某些特

定类型的数据，否则抛出硬件异常。

2. 性能原因 ：

数据结构 ( 尤其是栈 ) 应该尽可能地在自然边界上对齐。

原因在于，为了访问未对齐的内存，处理器需要作两次内存访问；而对齐的内存访问仅需要一次访

问。

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

那在设计结构体的时候，我们既要满足对齐，又要节省空间，如何做到：

struct S1
{
 char c1;
 int i;
 char c2;
};
struct S2
{
 char c1;
 char c2;
 int i;
};
//后者占用空间更小。在情况允许的时候，我们尽量设计成这样

修改默认对齐数：

//通过对宏的使用，#pragma pack()我们就可以修改默认对齐数
#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;
};
//修改的数最好的2^n的数

---

结构体传参：

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

传参只有两种。当把结构体传过去后，首先得内存得开辟一块空间复制结构体，所以会造成性能下降。传参建议都传地址。

---

位段：

位段定义：

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

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

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

如：

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

位段的内存分配：

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;

	return 0;
}

 位段的跨平台问题：

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

2. 位段中最大位的数目不能确定。（ 16 位机器最大 16 ， 32 位机器最大 32 ，写成 27 ，在 16 位机

器会出问题。

3. 位段中的成员在内存中从左向右分配，还是从右向左分配标准尚未定义。

4. 当一个结构包含两个位段，第二个位段成员比较大，无法容纳于第一个位段剩余的位时，是

舍弃剩余的位还是利用，这是不确定的。

总结

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

---

枚举

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

把可能的取值一一列举

枚举的定义：

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 ，当然在定义的时候也可以赋初值。

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

枚举的优点：

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

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

3. 防止了命名污染（封装）

4. 便于调试

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

枚举的使用：

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

---

联合（共用体）

联合也是一种特殊的自定义类型

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

联合类型的定义：

//联合类型的声明
union Un
{
 char c;
 int i;
};
//联合变量的定义
union Un un;

联合的特点：

联合的成员是共用同一块内存空间的，这样一个联合变量的大小，至少是最大成员的大小（因为联

合至少得有能力保存最大的那个成员）。

对于上面的程序：

 

联合大小的计算：

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

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

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

 

---

有什么问题希望可以评论区指出。