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

小菜坤日常上传gitee代码：​​​https://gitee.com/qi-dunyan​​ ❤❤❤ 个人简介：双一流非科班的一名小白，期待与各位大佬一起努力！

@TOC

1、结构体（struct）

1.0 结构体类型的声明

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

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

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

#include<stdio.h>
struct stu
{
  char name[20];//姓名
  int age;//年龄
  char id[12];//学号
  char class[20];//班级
};//切记这里的分号必须保留

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

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

#include<stdio.h>
struct 
{
  char name[20];//姓名
  int age;//年龄
  char id[12];//学号
  char class[20];//班级
};

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

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

#include<stdio.h>
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.1 结构的自引用

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

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

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

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

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

我们只需要把它写成结构体指针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

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

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

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

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

n2也是同理。4

1.3 结构体内存对齐

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

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

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

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

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

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

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

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

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

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

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

练习题

下面代码运行的结果为：

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

两者相比显然是传地址更加好一点，简单来说，在这里传值调用的时候，形参也要用一个该结构体大小的结构体变量来接收，但是传址调用，只需要用一个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
};

在这里，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;

我们通过调试可以发现，在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
};

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

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

枚举 vs #define 枚举的优点：

1. 增加代码的可读性和可维护性
2. 和#define定义的标识符比较，枚举有类型检查，更加严谨。#define 定义的只是一个标识符，也就是说，假如#define RED 10,在这里，RED是代表10的一个标识符，并没有具体类型。
3. 防止了命名污染（封装）
4. 便于调试
5. 使用方便，一次可以定义多个常量

3、 联合(union)

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

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

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

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

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

这里我们定义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、当最大成员大小不是最大对齐数的整数倍的时候，就要对齐到最大对齐数的整数倍。举个简单的例子：

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

end愿不负韶华，加油！❤