1.自定义类型：结构体的介绍

在之前的博客中，我们简单介绍过了关于结构体的基本知识，这里我们稍微复习一下。

结构体(struct)是C语言中一种重要的复合数据类型，它允许将不同类型的数据组合成一个整体。

1.1结构体的定义

结构体使用struct关键字定义，基本语法：

struct 结构体名 {数据类型 成员1;数据类型 成员2;// ...
};

 例如描述一个学生：

struct Stu {char name[20];int age;char sex[10];
};

1.2结构体的声明和初始化

struct Student {int id;char name[20];float score;
};// 方式1: 先定义结构体类型，再声明变量
struct Student stu1;// 方式2: 定义结构体类型的同时声明变量
struct Student {int id;char name[20];float score;
} stu2, stu3;// 方式3: 使用typedef创建别名
typedef struct {int id;char name[20];float score;
} Student;
Student stu4;//方法4：特殊声明，在声明结构体的时候，可以不完全声明
struct {int id;char name[20];float score;
}stu5;struct {int id;char name[20];float score;
}* stu6;stu6 = &stu5;

上述前三种声明都没有什么问题，而第四种声明我们要格外注意，我们在声明里省略了结构体标签，那么stu6 = &stu5这个代码能否能够正确运行呢？我们测试一下：

我们可以看到编译器报错了，编译器会把上面两个声明当成完全不同的类型。 

初始化结构体变量的方法一般有两种，如下：

struct Student {int id;char name[20];float score;
};//按定义顺序初始化
struct Student stu1 = { 20253265,"zhangsan",58.8 };//指定成员初始化
struct Student stu1 = { .id = 20251653,.name = "lisi",.score = 78.8 };

1.3结构体成员的访问

1.使用点运算符 . 访问结构体成员：

struct Student {int id;char name[20];float score;
};int main()
{struct Student stu1 = { 20253265,"zhangsan",58.8 };printf("%d\n", stu1.id);printf("%s\n", stu1.name);printf("%f\n", stu1.score);return 0;
}

 2.对于结构体指针，使用箭头运算符 ->访问成员：

struct Student {int id;char name[20];float score;
};int main()
{struct Student stu1 = { 20253265,"zhangsan",58.8 };struct Student* ps = &stu1;printf("%d\n", ps->id);printf("%s\n", ps->name);printf("%d\n", ps->score);return 0;
}

2. 结构体内存对齐

2.1对齐规则

学习上文已经使我们掌握了结构体的基本使用，现在我们要来深入探讨一个问题：计算结构体的大小。我们先来看一段代码：

struct S1 {char c1;char c2;int i;
};struct S2 {char c1;int i;char c2;
};int main()
{printf("%zd\n", sizeof(struct S1));printf("%zd\n", sizeof(struct S2));return 0;
}

大家可以猜一下这段代码的结果，会打印6，6吗，我们运行看结果：

 我们看到结果打印和我们预料结果完全不同，这是否说明在结构体中内存分配和正常内存分配有很大差异呢？答案是肯定的，我们先来学习结构体内存分配规则：对齐规则。

对齐规则：

1. 结构体的第一个成员对齐到和结构体变量起始位置偏移量为0的地址处

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

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

    - VS 中默认的值为 8

    - Linux中 gcc 没有默认对齐数，对齐数就是成员自身的大小

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

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

S1结构体的第一个变量c1对齐到和结构体变量起始位置偏移量为0的地址处,对应0字节空间，第二个成员变量为c2,对齐数为1（字符类型变量大小为1）和8（vs2022默认对齐数为8）的最小值,其实位置要对齐1的整数倍，对应1字节空间，第三个成员变量为i，对齐数为4（整型类型变量大小为4）和8（vs2022默认对齐数为8）的最小值，起始位置要对齐4的整数倍，对应4~7的字节空间。结构体总大小是最大对齐数的整数倍，S1结构体最大对齐数是4，要存入三个成员变量，至少需要8个字节，所以该结构体总大小为8个字节。如上图所示。

S2结构体的第一个变量c1对齐到和结构体变量起始位置偏移量为0的地址处,对应0字节空间，第二个成员变量为i,对齐数为4（整型类型变量大小为4）和8（vs2022默认对齐数为8）的最小值,起始位置要对齐4的整数倍，对应4~7字节空间，第三个成员变量为c2，对齐数为1（字符类型变量大小为4）和8（vs2022默认对齐数为8）的最小值，起始位置要对齐1的整数倍，对应8的字节空间。结构体总大小是最大对齐数的整数倍，S1结构体最大对齐数是4，要存入三个成员变量，至少需要9个字节，所以该结构体总大小为12个字节。如上图所示。

 解决了上述两个问题，我们在看一个存在结构体嵌套求解结构体内存大小的问题。

 S3结构体的第一个变量c1对齐到和结构体变量起始位置偏移量为0的地址处,对应0字节空间，第二个成员变量为s2,嵌套的结构体成员对齐到自己的成员中最大对齐数的整数倍处,对齐数为4，起始位置要对齐4的整数倍，对应4~15字节空间，第三个成员变量为d，对齐数为8（双精度浮点数类型变量大小为8）和8（vs2022默认对齐数为8）的最小值，起始位置要对齐8的整数倍，对应16~23的字节空间。结构体总大小是最大对齐数的整数倍，S3结构体最大对齐数是8，要存入三个成员变量，至少需要24个字节，所以该结构体总大小为24个字节。如上图所示。

其实我们在划分内存的时候，有些内存空间会被我们浪费掉，可不可以避免掉呢，其实是可以避免一部分的，在接下来的学习中我回讲到。

上述三体都是根据对齐规则求出来的，大家要好好掌握。

2.2为什么回存在内存对齐

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

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

2. 性能原因：

数据结构(尤其是栈)应该尽可能地在自然边界上对齐。原因在于，为了访问未对齐的内存，处理器需要作两次内存访问；而对齐的内存访问仅需要一次访问。假设一个处理器总是从内存中取8个字节，则地址必须是8的倍数。如果我们能保证将所有的double类型的数据的地址都对齐成8的倍数，那么就可以用个内存操作来读或者写值了。否则，我们可能需要执行两次内存访问，因为对象可能被分放在两个8字节内存块中。

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

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

//例如：
struct S1//8
{char c1;int i;char c2;
};struct S2//12
{char c1;char c2;int i;
};

 S1 和 S2 类型的成员⼀模⼀样，但我们让占有空间小的成员集中在一起，可以让结构体所占空间大小变小一点。

 2.3修改默认对齐数

用#pragma这个预处理指令，可以改变编译器的默认对齐数。

 可以看到我们将默认对齐数改为1，结构体所占内存空间变为了6个字节，减少了很大一部分空间。

结构体在对齐方式不合适的时候，我们可以自己更改默认对齐数。

 3.结构体传参

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和print2函数那个好一些？首选print2函数。

 原因：

函数传参的时候，参数是需要压栈，会有时间和空间上的系统开销。如果传递⼀个结构体对象的时候，结构体过⼤，参数压栈的的系统开销⽐较⼤，所以会导致性能的下 降。

结构体传参的时候，要传结构体的地址。

4.结构体实现位段

4.1什么是位段

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

1. 位段的成员必须是 int 、 unsigned int 或 signed int ，在C99中位段成员的类型也可以

选择其他类型。

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

比如：

struct A
{int _a : 2;//代表该变量在内存空间中仅占2个bit位int _b : 5;//代表该变量在内存空间中仅占5个bit位int _c : 10;//代表该变量在内存空间中仅占10个bit位int _d : 30;//代表该变量在内存空间中仅占30个bit位
};

这就是一个典型的位段示例。它可以控制成员在内存中所占bit位的个数，那么他总共占的内存空间有多大呢？

位段的内存分配规则很大一部分取决于编译器，以作者所用的vs2022环境下举例，看以下代码：

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

从调试结果看，所占空间为3个字节。我们来分析过程：

a = 10,二进制为01010，而结构体位段规定a中只能存放3个bit位的数据，所以存010

b = 10,二进制为01100，而结构体位段规定a中只能存放4个bit位的数据，所以存1100

c = 10,二进制为00011，而结构体位段规定a中只能存放5个bit位的数据，所以存00011

a = 10,二进制为00100，而结构体位段规定a中只能存放4个bit位的数据，所以存0100

知道它们在内存中存的是什么之后，我们还有一个问题，它们是按什么顺序，什么规则存进去呢？ 在vs2022环境下,在一个字节中，他要从高地址往低地址存放，第一个字节8个bit位存01100010，最高位之所以是0，是因为下一个数据占5个bit位的内存，1个bit位存不下，所以只能存放至下一个字节中（下同），第二个字节存00000011，第三个字节存00000100，最后在调试结果下从低地址到高地址分别为：0x62,0x03,0x04。

4.2位段的跨平台问题

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

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

3.位段中的成员在内存中从左向右分配，还是从右向左分配标准尚未定义。（vs2022环境下，从右向左，也就是从高地址向低地址存）

4.当一个结构包含两个位段，第二个位段成员比较大，无法容纳于第一个位段剩余的位时，是舍弃剩余的位还是利用，这是不确定的。（vs2022环境下，舍弃）

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

4.3位段的应用 

4.4位段使用的注意事项

struct A
{int _a : 2;int _b : 5;int _c : 10;int _d : 30;
};
int main()
{struct A sa = { 0 };scanf("%d", &sa._b);//这是错误的//正确的⽰范int b = 0;scanf("%d", &b);sa._b = b;return 0;
}