结构体讲解

一.结构体类型的声明

(1)结构体的声明

(2)结构体的创建和初始化

(3)匿名结构体

(4)结构体的自引用

二.结构体内存对齐

(1)对齐规则

(2)为什么存在内存对齐？

(3)结构体传参

三.结构体实现位段

(1)什么是位段

(2)位段的内存分配

(3)位段的跨平台问题

一.结构体类型的声明

(1)结构体的声明

struct tag
{member-list;
}variable-list;

结构体是一些值的集合，这些值称为成员变量。结构体的每一个变量可以是不同的类型。

例如使用结构体描述一个学生：

struct Stu
{char name[20];//名字int age;//年龄char sex[5];//性别
};//这里可以不写

(2)结构体的创建和初始化

#include<stdio.h>
struct Stu
{char name[20];//名字int age;//年龄char sex[5];//性别
};//这里可以不写int main()
{struct Stu s1 = { "张三",18 ,"男"};//结构体成员的初始化要按顺序进行。	// struct Stu s1 = { "张三","男"，18};//这样就是不行的。printf("%s ",s1.name);printf("%d ",s1.age);printf("%s ",s1.sex);printf("\n");//也可以指定进行初始化struct Stu s2 = {.age = 18,.name = "李四",.sex = "女"};printf("%s ", s2.name);printf("%d ", s2.age);printf("%s ", s2.sex);return 0;
}

(3)匿名结构体

在声明结构体的时候，可以不完全的声明。

struct
{int a;char b;float c;
}x;struct
{int a;char b;float c;
}a[20], * p;

这两个结构体就省略掉了结构体标签（tag）

那么问题来了？

第一个结构体和第二个结构体的成员变量都是一模一样的。

p = &x;

这个代码是否有问题？

warning C4133: “=”: 从“*”到“*”的类型不兼容

编译器会发生警告，这两个结构体是不同的类型，所以是非法的。

匿名的结构体类型，如果没有对结构体类型进行重命名的话，基本上是只能使用一次。

(4)结构体的自引用

在一个结构体中包含一个类型为结构体本身的成员是否可以呢？
比如定义一个链表的节点：

struct Node
{int val;struct Node next;
};

上面的代码正确吗？

结构体的大小应该是固定的，一个结构体包含自己和另一个整形变量，这肯定是不合理的，这样的变量会无穷大。正确的自引用应该是包含一个结构体指针指向下一个结构体。

typedef struct
{int val;Node* next;
}Node;

这个代码可行吗？

答案是不行的，因为Node是对前面的匿名结构体进行了重命名，但是在匿名结构体内存提前使用了Node类型的变量来创建成员变量，这是不行的。

所以在定义结构体的过程中尽量不要使用匿名结构体。

二.结构体内存对齐

我们已经掌握了结构体的基本使用，现在我们可以深入讨论一个问题：结构体的大小？

#include<stdio.h>
struct s1
{int a;char b;
};
struct s2
{char a;int b;char c;
};
int main()
{printf("%zd\n",sizeof(struct s1));printf("%zd\n",sizeof(struct s2));return 0;
}

思考一下s1和s2所占字节是多少？

输出结果：

struct s1的大小是8个字节，为什么不是4（int）+ 1(char)=5个字节呢？？？

同理为什么struct s2不是6个字节呢？

说明在这个结构体中内存是存在一定的浪费的。

(1)对齐规则

偏移量就是距离结构体第一个字节的距离，第一个字节的偏移量是0，第二个偏移量是1，同理依次类推。

struct s1
{int a;char b;
};

我们先来计算这个结构体的大小。

规则1：就是结构体的第一个成员要放在最前面的位置

也就是int占据前4个字节。

什么是对齐数呢？

除了第一个成员变量之外，其他的结构体成员是需要对齐到某个数字开始存储的。

在vs2022中的对齐数是8，在Linux，gcc中是没有默认对齐数的，对齐数是成员自身的大小。

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

例如在vs2022中 char的对齐数就是 1 （1 < 8）;int 的对齐数就是4 (4 < 8);

讲解完了对齐数，回到上面那个问题。

第二个成员变量char 是要对齐到它的对齐数的整数倍处。而任何数都是1的整数倍，所以char就放在int的后面即可。

第三条规则：结构体的总大小为最大对齐数的整数倍。

最大对齐数是所有结构体成员变量的对齐数的最大值。

通过前两个规则我们知道， char的对齐数就是 1 （1 < 8）;int 的对齐数就是4 (4 < 8)，所以最大对齐数是4;而且已经占据了5个字节，但是并不是4的整数倍，所以这个结构体的大小要自动补齐到八个字节。

所以这个结构体的大小是8个字节。

那么我们现在来计算struct s2 的字节

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

第一个结构体成员变量发在第一个字节，而第二个结构体成员int对齐到4的整数倍处也就是从偏移量4的字节开始占据4个字节，然后第三个结构体成员变量char对齐1的整数倍处，也就是偏移量8的字节，最大对齐数是4，根据第三条规则结构体的大小就应该是4的整数倍，也就是12了。

结构体嵌套问题

我们把结构体struct s2 改变一下，

struct s1
{int a;char b;
};
struct s2
{char a;int b;char c;struct s1 d;
};

那么此时的struct s2 的大小是多少？

规则4：嵌套的结构体要对齐到该结构体成员变量中最大对齐数的整数倍处。

结构体s1的最大对齐数是4，所以d应该对齐到4的整数倍处

这时候已经占据了20个字节，再根据规则三:整个结构体的最大对齐数4，而20刚好是4的倍数，所以不再变大了，这个结构体的大小就是20.

#include<stdio.h>
struct S3
{double d; char c;int i;
};
struct S4
{char c1;struct S3 s3;double d;
};
int main()
{printf("%zd\n", sizeof(struct S3));printf("%zd\n", sizeof(struct S4));
}

struct s3:

不难推断处结构体s3的大小是16；

结构体s3的最大对齐数是8，故对齐到偏移量为8的位置，大小16个字节。s4的最大对齐数就是8，也要对齐，刚好32就是8的倍数，所以这个结构体的大小就是32；

(2)为什么存在内存对齐？

平台原因：
不是所有的硬件平台都能够访问任意的地址上的任意数据的；某些硬件平台只能在某些地址处取某些特定的类型的数据，否则会抛出硬件异常。
性能原因：
数据结构（尤其是栈）应该尽可能地在自然边界上对齐。原因在于，为了访问未对齐的内存，处理器需要进行两次内存的访问；而对齐的内存访问只需要一次。假设一个处理器总是从内存中取八个字节，则地址必须是8的倍数。如果我们能保证将所有的double类型的数据的地址都对齐成8的倍数，那么就可以用一个内存操作做来读或者写值了。否则，计算机可能需要执行两次内存访问，因为对象可能会被分放在两个8字节的内存块中。

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

那么在我们设计结构体时候，我们既要满足对齐，又要尽可能的节省空间

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

我们发现第二个结构体的大小明显小于第一个。

让占用空间小的成员尽可能的集中在一起。

(3)修改默认对齐数

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

#include<stdio.h>
#pragma pack(1)//将默认对齐数设置为1
struct S3
{double d; char c;int i;
};
struct S4
{char c1;struct S3 s3;double d;
};
int main()
{printf("%zd\n", sizeof(struct S3));printf("%zd\n", sizeof(struct S4));
}

再次运行代码我们就会发现结果已经不一样了。

#pragma pack()

再加上这个就可以取消对齐数，还原为默认值。

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

(3)结构体传参

#include<stdio.h>
struct S
{int arr[1000];int n;double d;
};
void print1(struct S tmp)
{int i = 0;for (i = 0; i < 5; i++){printf("%d ", tmp.arr[i]);}printf("%d ", tmp.n);printf("%lf\n", tmp.d);
}
void print2(const struct S* ps)
{int i = 0;for (i = 0; i < 5; i++){printf("%d ", ps->arr[i]);}printf("%d ", ps->n);printf("%lf ", ps->d);
}
int main()
{struct S s = { {1,2,3,4,5}, 100, 3.14 };print1(s);print2(&s);return 0;
}

观察print1和print2函数，这两个函数都是在打印这个结构体，那么这两个结构体有什么区别呢？或者他们两个哪一个更好？

答案是print2函数

函数传参的时候，参数是需要压栈的，会有时间和空间上的系统开销。

如果传递一个结构体对象的时候，结构体过大，参数压栈的系统的开销比较大，所以会导致性能下降。

所以为了避免这样的情况，结构体传参的时候，要传结构体的地址。

三.结构体实现位段

不是段位

(1)什么是位段

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

位段的成员必须是int 或者unsigned int或者signed int ,在C99中位段成员的类型也可以选择其他类型
位段的成员名后面后一个冒号和一个数字。

struct A
{int a:2;int b:5;int c:10;int d:30;
};

A就是一个位段类型

那么位段A所占内存的大小是多少？

答案是8.为什么呢？

变量名的后面跟着一个冒号数字代表这个数字只占多少个bit位。

比如int c:10,表示这个c变量占据了10个bit位。

而我们知道正常的一个int类型的变量是4个字节，占据32个bit位。

所以这样位段可以节省内存。

首先分配4个字节的空间存储a,还剩30个bit，然后在把b放进去，还剩25个bit，再把c放进去，只剩15个bit了不够容纳d了，所以再分配4个字节的空间，然后把d放进去。总共使用了8个字节，所以这个结构体的大小是8个字节。

(2)位段的内存分配

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

在vs2022上，申请到的一块空间是从右向左使用的。但是不同的平台这是不确定的。

10的二进制是1010，但是a只有3位，所以存入010，

12的二进制是1100，b有4位，存入1100

3的二进制是0011，c有5位存入0011

4的二进制0100，存入0100

所以从低到高，十六进制0x62 0x03 0x04，总共占据三个字节

(3)位段的跨平台问题

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

总的来说：更结构体相比，位段可以达到同样的效果，并且可以很好的节省空间，但是有跨平台的问题存在。

(4)位段使用的注意事项

位段的成员共有一个字节，这样有些成员的起始地址并不是某个字节的起始位置，那么这些位置处是没有地址的，内存中的每一个字节分配一个地址，一个字节内部的bit位是没有地址

所以不能使用取地址操作符&利用scanf直接给位段的成员输入值，只是先输入放在一个变量中然后赋值给位段的成员。

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