关于C语言的知识放在专栏：C
小菜坤日常上传gitee代码：https://gitee.com/qi-dunyan
???
个人简介：双一流非科班的一名小白，期待与各位大佬一起努力！
主要目录
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:默认的值为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;
};
//原理同上
画个图来对比一下两者之间的差别：
为什么要存在结构体内存对齐呢？主要有以下两个好处：
-
平台原因(移植原因)：
不是所有的硬件平台都能访问任意地址上的任意数据的；某些硬件平台只能在某些地址处取某些特定类型的数据，否则抛出硬件异常。 -
性能原因：
数据结构(尤其是栈)应该尽可能地在自然边界上对齐。
原因在于，为了访问未对齐的内存，处理器需要作两次内存访问；而对齐的内存访问仅需要一次访问。
总之结构体内存对齐是拿空间来换取时间。
练习题
下面代码运行的结果为：
#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）的大小是多少呢？诸君莫急，且往下看：
要计算它的大小，首先我们要了解位段的内存分配是如何实现的。
- 位段的成员可以是 int unsigned int signed int 或者是 char （属于整形家族）类型
- 位段的空间上是按照需要以4个字节（ int ）或者1个字节（ char ）的方式来开辟的。
- 位段涉及很多不确定因素，位段是不跨平台的，注重可移植的程序应该避免使用位段。
而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标准里并没有关于它的规定！
在一些情况下，跟结构相比，位段可以达到同样的效果，但是可以很好的节省空间，但是有跨平台的问题存在。所谓的跨平台问题主要是以下几点：
- int 位段被当成有符号数还是无符号数是不确定的。
- 位段中最大位的数目不能确定。（16位机器最大16，32位机器最大32，写成27，在16位机
器会出问题。 - 位段中的成员在内存中从左向右分配，还是从右向左分配标准尚未定义。
- 当一个结构包含两个位段，第二个位段成员比较大，无法容纳于第一个位段剩余的位时，是
舍弃剩余的位还是利用，这是不确定的
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
枚举的优点：
-
增加代码的可读性和可维护性
-
和#define定义的标识符比较，枚举有类型检查，更加严谨。
#define 定义的只是一个标识符，也就是说，假如#define RED 10,在这里，RED是代表10的一个标识符，并没有具体类型。 -
防止了命名污染（封装）
-
便于调试
-
使用方便，一次可以定义多个常量
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
愿不负韶华，加油！?