【C/自定义类型详解】——结构体（struct）、位段、枚举(enum)、联合(union)

关于C语言的知识放在专栏：C
小菜坤日常上传gitee代码：https://gitee.com/qi-dunyan
❤❤❤
个人简介：双一流非科班的一名小白，期待与各位大佬一起努力！

1、结构体（struct）

1.0 结构体类型的声明

我们通常会用一个变量来定义一个事物，就比如我们要进行求和，我们通常会创建一个sum的变量来存放求和的结果，最终再打印sum，此时的sum就表示我们最终的求和结果。

但是，在生活中，有很多事物很难用一两句话来表示，就比如说一个学生，一个学生通常会由姓名、年龄、学号、班级…等很多信息来组成。

在C语言中也是如此，对于一个复杂对象，C语言提供了结构体，就拿上面的学生例子来说，对于这么一个复杂对象的描述，C语言是这样实现的。

#include
struct stu
{
	char name[20];//姓名
	int age;//年龄
	char id[12];//学号
	char class[20];//班级
};//切记这里的分号必须保留
1
2
3
4
5
6
7
8

在这里，姓名、年龄、学号、班级，这些属于结构体成员变量，结构体成员变量的类型可以不同。

1.0.1结构体的特殊声明
对于上面的例子，我们在声明结构体的时候，可以去掉stu,就变成：

#include
struct 
{
	char name[20];//姓名
	int age;//年龄
	char id[12];//学号
	char class[20];//班级
};
1
2
3
4
5
6
7
8

这就是结构体的不完全声明，大家可以理解为匿名类的声明。

对于结构体不完全声明，假如有以下这种情况：

#include
struct
{
	int a;
	char b;
	float c;
}x;//在声明结构体时，我们可以顺便创建结构体变量，这里的x就是一个结构体变量，类型为struct 
   //同时，在声明结构体时创建的变量是属于全局变量，因为它不在大括号内！
struct
{
	int a;
	char b;
	float c;
}a[20], * p;
//这里的p表示是一个结构体指针变量，可以用来存放结构体变量的地址

int main()
{
	//假如把x的地址存放到p中，会发生什么？
	p = &x;
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

此时，如果运行的话，编译器会报错，如下图：

这就意味着编译器会把上面的两个声明当成完全不同的两个类型（两者本应都是结构体类型的变量，但不完全声明会使编译器以为两者的类型不同）。所以才会出现报错这种情况。

1.1 结构的自引用

大家看如下代码，假如我想在结构中包含一个类型为该结构本身的成员，以下这个代码是否可行？

struct Node
{
 int data;
 struct Node next;
};
1
2
3
4
5

答案是否定的，为什么呢？因为假如可行的话，这个结构体就会无限包含，如下：

会无限循环下去，这样的话，假如我们要计算它的大小，那么它的大小也是一个趋近于无限大的数，因为会一直包含，那假如一定要实现结构体包含一个结构体类型为该结构体呢？正确写法应该如下：

struct Node
{
 int data;
 struct Node* next;
};
1
2
3
4
5

我们只需要把它写成结构体指针struct Node*的形式，这就意味着该指针指向的对象类型也是struct Node，就实现了在一个结构体中，包含一个类型为该结构本身的成员。同样，该成员作为一个指针存放在结构体中，它的大小为4（8）个字节。就不会出现上面这种“无限套娃”的现象。

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

结构体变量的定义有两种方法，一种是在声明结构体的同时，定义结构体变量，另一种就是直接定义结构体变量，如下：

struct Point
{
 int x;
 int y;
}p1; //声明类型的同时定义变量p1，p1的类型为struct Point
struct Point p2; //定义结构体变量p2,P2的类型为struct Point
1
2
3
4
5
6

在定义结构体变量的时候，我们也可以进行初始化：

struct Point
{
 int x;
 int y;
}p1={1，2};//p1结构体成员中的x=1，y=2 
struct Point p2={3，4}; //p2结构体成员中的x=3，y=4 
1
2
3
4
5
6

另外，结构体变量是可以实现嵌套初始化的，如下所示：

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
2
3
4
5
6
7
8
9
10
11
12

n2也是同理。4

1.3 结构体内存对齐

我们知道，每个类型的变量都有它的大小（单位：字节），就比如，sizeof(int) ==4、sizeof(short) 的大小为2…

那么对于一个结构体来说，它的大小是多少呢？它的大小跟它的结构体成员变量之间有什么关系呢？ 这里就涉及到了**结构体内存对齐**。话不多说，直接上代码演示：

#include
struct S1
{
	char a;
	char b;
	int c;
};

struct S2
{
	char a;
	int c;
	char b;
};

int main()
{
	printf("%d \n", sizeof(struct S1));
	printf("%d \n", sizeof(struct S2));
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

在这里，我们可能会猜测，s1的大小与s2的大小相同，都是6byte，所以打印出来的是6 6，实际结果到底如何呢？

我们看到，这两种结果都和我们预想的不同，究竟为何呢？在这里，我们先来了解以下偏移量的概念，以及偏移量的计算，如下：

我们再来介绍一下offsetof，专门用来计算偏移量的一个宏。头文件需要包含

我们通过偏移量来分析一下：


以上只是我们对结构体内存对齐的猜测验证，结构体内存对齐是遵循以下规则的：

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

2. 其他成员变量要对齐到某个数字（对齐数）的整数倍的地址处。
对齐数 = 编译器默认的一个对齐数 与 该成员大小的较小值。
VS:默认的值为8
linux:不设默认对齐数，即结构体成员的大小就是它本身的对齐数

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

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

具体到底是什么意思呢？第一条我们很好理解，就是第一个成员从偏移量为0的位置开始， 那么后面的具体是什么意思呢？还是来看上面的例子：

struct S1
{
            //单位：字节
	char a;//a是第一个结构体成员，所以a从偏移量为0的位置开始，大小一个字节
	char b;//b的大小为1，vs默认值8，1<8,所以它的默认对齐数为1，从偏移量为1的整数倍开始
	int c;//大小4，4<8,所以对齐数为4，所以从偏移量为4的整数倍开始	
	//总大小为1+1+4=6byte，三个成员中最大对齐数为4，所以结构体的大小应为4的整数倍

};
struct S2
{
	char a;
	int c;
	char b;
};
//原理同上
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

画个图来对比一下两者之间的差别：

为什么要存在结构体内存对齐呢？主要有以下两个好处：

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

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

练习题

下面代码运行的结果为：

#pragma pack(4)/*编译选项，表示4字节对齐 平台：VS2013。语言：C语言*/
//#pragma pack()可以用来修改默认对齐数
int main(int argc, char* argv[])
{
  struct tagTest1
  {
    short a;//2   
    char d; //1
    long b; //4  
    long c; //4  
    //最大对齐数：4
  };
  struct tagTest2
  {
    long b;   //4
    short c;//2
    char d;//2
    long a;//4   
   //最大对齐数：4
  };
  struct tagTest3
  {
    short c;//2
    long b;//4
    char d;  //1 
    long a;  //4 
  //最大对齐数：4
  };
  struct tagTest1 stT1;
  struct tagTest2 stT2;
  struct tagTest3 stT3;

  printf("%d %d %d", sizeof(stT1), sizeof(stT2), sizeof(stT3));
 // 三个结构体都向最长的4字节long看齐。第一个a+d+b才超过4字节，所以a和d一起对齐一个4字节，剩下两人独自占用，共12字节
 //第二个同理c，d合起来对齐一个四字节，也是12字节。
 //第三个因为c+b，d+a都超过4字节了，所以各自对齐一个4字节，共16字节。
 //所以打印12 12 16
  return 0;
}
#pragma pack()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40

在设计结构体的时候，我们既要满足对齐，又要节省空间，所以我们应尽量让同一类型的成员集中在一起。

1.4 结构体传参

在调用函数时，结构体传参也是与我们常用到的变量传参一样，有两种方式，一种为传值调用，另一种为传址调用，如下：

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
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

两者相比显然是传地址更加好一点，简单来说，在这里传值调用的时候，形参也要用一个该结构体大小的结构体变量来接收，但是传址调用，只需要用一个4/8字节的结构体指针变量来接收，两者差别显而易见。

因此，在调用函数，结构体传参时，尽可能传址调用

1.5 结构体实现位段

位段是什么？
位段，C语言允许在一个结构体中以位为单位来指定其成员所占内存长度，这种以位为单位的成员称为“位段”或称“位域”( bit field) 。利用位段能够用较少的位数存储数据。

位段的声明和结构是类似的，有两个不同：
1.位段的成员必须是 int、unsigned int 或signed int 。
2.位段的成员名后边有一个冒号和一个数字。

举个例子：

struct A
{
 int _a:2;//这里的2表示a占用两个bit位
 int _b:5;//5bit
 int _c:10;//10bit
 int _d:30;//30bit
};
1
2
3
4
5
6
7

在这里，A就是一个位段类型，那么sizeof（struct A）的大小是多少呢？诸君莫急，且往下看：

要计算它的大小，首先我们要了解位段的内存分配是如何实现的。

1. 位段的成员可以是 int unsigned int signed int 或者是 char （属于整形家族）类型
2. 位段的空间上是按照需要以4个字节（ int ）或者1个字节（ char ）的方式来开辟的。
3. 位段涉及很多不确定因素，位段是不跨平台的，注重可移植的程序应该避免使用位段。
   而C99标准里并没有进行对于位段的内存分布的明确规定！
   所以这里我们在VS平台下不妨对它进行大胆假设。如下：

struct S
{
 char a:3;
 char b:4;
 char c:5;
 char d:4;
};
struct S s = {0};
s.a = 10;
s.b = 12;
s.c = 3;
s.d = 4;
1
2
3
4
5
6
7
8
9
10
11
12

我们通过调试可以发现，在vs环境下确实是从低地址向高地址存储，当字节空间并不足以放下下一个变量时，会再次开辟字节空间继续从低地址向高地址处存储。

那么再回过头来看前面的那个题就简单了，首先开辟一个int类型的空间大小，即4byte，a、b、c一共占用17bit，剩下的15bit不够存放d，所以再次开辟一个int类型的空间，即4byte，所以一共8byte！

但并不保证别的平台也是如此，因为C99标准里并没有关于它的规定！

在一些情况下，跟结构相比，位段可以达到同样的效果，但是可以很好的节省空间，但是有跨平台的问题存在。所谓的跨平台问题主要是以下几点：

1. int 位段被当成有符号数还是无符号数是不确定的。
2. 位段中最大位的数目不能确定。（16位机器最大16，32位机器最大32，写成27，在16位机
   器会出问题。
3. 位段中的成员在内存中从左向右分配，还是从右向左分配标准尚未定义。
4. 当一个结构包含两个位段，第二个位段成员比较大，无法容纳于第一个位段剩余的位时，是
   舍弃剩余的位还是利用，这是不确定的

2、枚举(enum)

枚举就是列举，即把可能的取值一一列举。就比如一周可以有周一、周二…一直到周日，
再比如颜色可以有红橙黄绿蓝靛紫…就是把所有的可能列举出来

在C语言中是这样来定义的：

enum Day//星期
{
 Mon,
 Tues,
 Wed,
 Thur,
 Fri,
 Sat,
 Sun
};
enum Sex//性别
{
 MALE,
 FEMALE,
 SECRET
}；
enum Color//颜色
{
 RED,
 GREEN,
 BLUE
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

{}中的内容是枚举类型的可能取值，也叫枚举常量。
既然是枚举常量，那么就会有对应的值，这些值默认从0开始，一次递增1，在定义的时候也可以赋初值。如下：

#include
enum Color
{
	RED,
	YELLO,
	GREEN=10,//（注意这里是逗号）
	BLUE//注意这里没有逗号
};

int main()
{
	printf("%d %d %d %d", RED,YELLO, GREEN, BLUE);//0 1 10 11
	printf("%d",sizeof(enum Color));//4,因为enum只是列举出所有可能，但是！它只有一个才是真正需要的（并不是所有的可能都需要），所以这里打印出来的是一个整形的大小，4
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

枚举 vs #define
枚举的优点：

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

2. 和#define定义的标识符比较，枚举有类型检查，更加严谨。
   #define 定义的只是一个标识符，也就是说，假如#define RED 10,在这里，RED是代表10的一个标识符，并没有具体类型。

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

4. 便于调试

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

3、 联合(union)

联合又叫联合体、共用体，它也是一种特殊的自定义类型
这种类型定义的变量也包含一系列的成员，特征是这些成员公用同一块空间，如下：

#include
union Un
{
	int i;
	char c;
};
int main()
{
	union Un un;
	printf("%d", sizeof(un));//4
	return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13

在这里，i和c共用一块空间，如下：

特点就是同生共死，即在使用i的同时，也会影响c的使用，举个例子：

#include
union Un
{
	int i;
	char c;
};
int main()
{
	union Un un;
	//un.i = 10;
	un.i=256；//100000000,un的第一个字节存储的是00000000，所以打印0
	printf("%d", un.c);//10  0
	return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

这里我们定义i的值为10，但是为什么打印的明明是c，结果也是10呢？
很简单，因为它们共用一块内存。

但是！假如i的值超过了255，即超过一个字节所对应的1111 1111（255），此时再打印c的值，就与i不同了。

联合体的使用

百度笔试题：

判断当前计算机的大小端存储

这道题在之前的文章中写过了一种方法，就是先定义一个变量，初始化为1，然后强制类型转换为char*，然后解引用，就会访问第一个字节，如果是1，就说明是小端，反之大端存储。

这里我们还可以用联合体的巧妙性来解:

union un
{
	int i;
	char m;
};
int main()
{
	union un q;
	q.i = 1;
	if (q.m == 1)
	{
		printf("小端");
	}
	else
		printf("大端");
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

原理如下：

联合体大小的计算

联合大小的计算应遵循以下原则：
1、联合的大小至少是最大成员的大小。
2、当最大成员大小不是最大对齐数的整数倍的时候，就要对齐到最大对齐数的整数倍。
举个简单的例子：

union Un1
{
 char c[5];//5 对齐数：1
 int i;//4对齐数：4，最大成员大小为5，不是最大对齐数4的整数倍，所以要对齐到8，所以该联合体大小为8
};
union Un2
{
 short c[7];//14 对齐数：1
 int i;//4  对齐数：4，最大成员大小为14，不是最大对齐数4的整数倍，所以对齐到16，该联合体大小为16byte
};

printf("%d\n", sizeof(union Un1));//8
printf("%d\n", sizeof(union Un2));//16
1
2
3
4
5
6
7
8
9
10
11
12
13

end
愿不负韶华，加油！❤