目录
结构体的特殊声明
前置知识
int a = 0；//定义了一个整型变量a我们都知道这是定义了一个int类型的变量a，那么有没有什么方法可以定义一个“书”类型呢？
描述一本书，需要书名，作者，出版社，定价等信息，在编译器中并没有“书”这种类型，这就需要结构体
struct Book //定义了一个书类型
{
//成员变量
char name[20]; //书名
char writer[20]; //作者
int price; //价钱
} book1，book2; //分号不能丢
//创建了book1和book2两个对象特殊的声明
在声明结构的时候，可以不完全的声明
struct //省略了类型名，匿名结构体类型
{
int a;
char n;
double b;
}S; //直接利用匿名结构体类型创建了一个变量S这就叫匿名结构体类型
知道了匿名结构体类型，现在出现了一个问题
以下代码合法吗？
struct
{
int a;
char n;
double b;
}S;
struct
{
int a;
char n;
double b;
}* ps; //匿名结构体变量的指针
int main()
{
ps = &S;
return 0;
}答：不合法，在编译器看来，虽然两个匿名结构体的成员一模一样，但是仍然被认为是不同的类型 ，因此指针变量ps不能存S的地址
匿名结构体使用的一次性
匿名结构体只在一个函数或一个小的作用域内被用来传递数据。因为它没有被命名，所以在一次使用后通常不会被再次使用，可以被视为一次性使用
#include <stdio.h>
int main() {
// 初始化一个没有命名的结构体
struct {
char *name;
int age;
} person = {"Alice", 30};
// 使用这个没有命名的结构体中的数据
printf("Name: %s\n", person.name);
printf("Age: %d\n", person.age);
return 0;
}在这个例子中，我们在 main 函数内部创建了一个结构体并直接初始化了它的成员 name 和 age，而没有为这个结构体类型取名。然后我们创建了一个这个结构体的变量 person 并打印了它的内容。这种结构体通常是一次性的，因为在其定义之外它是不可见的，不能够在其他地方重复使用
不可见：指的是不能再次创建相同的结构体类型实例，因为该类型没有全局识别的名称。这是匿名结构体的局限之一，在使用时需要留意 ,比如下述代码
#include <stdio.h>
int main() {
struct {
char *name;
int age;
} person;
struct person1;//error
return 0;
}不能在其他地方重新使用：如果你需要在你的程序的多个地方使用这个结构，你应该定义一个具有名字的结构体类型。这样，相同的结构体类型就可以在你的整个程序中重复使用，并且可以被函数等作为参数和返回类型所引用
#include <stdio.h>
int main() {
struct identity //定义了一个身份类型
{
char *name;
int age;
} person;
struct identity person1;
struct identity person2;//创建了两个身份类型的变量person1和person2
return 0;
}结构的自引用
引入
在结构体初阶中我们知道，结构体的成员可以是另一个结构体
比如
struct A
{
char a;
int b;
short c;
};
struct B
{
int k;
struct A a; //结构体的成员是另一个结构体
char h;
};那么，在结构体中包含一个类型为该结构本身的成员是否可以呢？
struct day
{
int year;
struct day aday; //是否可行？
};
答：不可以，永远会嵌套自己，结构体成员包含一个类型为结构本身的成员是不现实的。那么如何进行正确的自引用呢？
正确的自引用
struct node
{
int data;
struct node* next;
};为什么这样写呢？我们要引入数据结构的知识
链表
现在随机存放了1,2,3,4,5五个元素
| 5 | ||||
| 2 | ||||
| 1 | ||||
| 4 | 3 |
我们将每一个元素存放的位置称作节点，现在要将多个节点按照12345的顺序串起来，该如何实现呢？
为了使1的后面能找到2，我们把2的地址存到1的位置，以此类推，每一个节点都存放了数据和下一个节点的地址。（5的位置没有下一个节点，所以存放空指针NULL）
我们发现节点分为两部分
节点
数据域--存放数据 指针域--存放下一个节点的地址
因此指针域应该是一个结构体指针
struct node
{
int data;
struct node* next; //struct node* 代表存放的下一个节点和本身的类型相同
};这样就找到了同类型的下个节点 （关于链表的实现会在数据结构中描述）
结构体内存对齐
引入
我们现在要讨论一个问题：计算结构体的大小
struct S
{
char a;
int b;
char c;
};
int main()
{
sizeof(struct S); //结果是多少？
return 0;
}要想计算这个结构体的大小，首先要知道结构体的对齐规则
结构体的对齐规则
1.第一个成员在与结构体变量偏移量为0的地址处
2.其他成员变量要对齐某个数字（对齐数）的整数倍的地址处
对齐数 = 编译器默认的一个对齐数与该成员大小的较小值 vs编译器中默认的对齐数是8
3.结构体总大小为最大对齐数（每个成员变量都有一个对齐数）的整数倍
4.如果嵌套了结构体的情况，嵌套的结构体对齐到自己的最大对齐数的整数倍处，结构体的整体大小就是所有最大对齐数（含嵌套结构体的对齐数）的整数倍
我们一条一条细说奥，以下述代码为例计算结构体大小
struct s
{
char a;
int b;
char c;
};
int main()
{
struct s s1={ 0 }; //创建了一个s类型变量s1，并把s中的a初始化为0，b和c为默认值
//sizeof(s1)是多少呢？
}这是一块内存空间
| 假如从这个位置开始开辟 |
1.第一个成员在与结构体变量偏移量为0的地址处
| 假如从这个位置开始开辟，则该位置偏移量为0，因此变量a存放在这个位置 |
| 偏移量为1 |
| 2 |
| 3 |
| 4 |
| 5 |
| 以此类推 |
2.其他成员变量要对齐某个数字（对齐数）的整数倍的地址处
对齐数 = 编译器默认的一个对齐数与该成员大小较小值 ，vs编译器中默认的对齐数是8
3.结构体总大小为最大对齐数的整数倍（每个成员变量都有一个对齐数）
首先我们来看怎么计算对齐数
struct s
{
char a; //char类型占1个字节，vs默认对齐数是8，取较小值，因此该成员变量的对齐数是1
int b; //int类型占4个字节，vs默认对齐数是8，取较小值，因此该成员变量的对齐数是4
char c; //由上得，该变量对齐数是1
}; //每个成员变量都有一个对齐数
int main()
{
struct s s1={ 0 };
}接下来要继续存放变量b，b是int类型，对齐数是4，要存放在4的整数倍的地址处，因此
| 0 a |
| 1 |
| 2 |
| 3 |
| 4 b |
| 5 b |
| 6 b |
| 7 b int占4个字节 |
| 8 |
| 9 |
| 10 |
接着存放变量c，c的对齐数是1，所有数都是1的整数倍，因此
| 0 a |
| 1 未使用 |
| 2 未使用 |
| 3 未使用 |
| 4 b |
| 5 b |
| 6 b |
| 7 b |
| 8 c |
| 9 |
| 10 |
由此图可知现在变量s1占了9个字节，但sizeof（s1）的结果真的是9吗？
这是因为第3点，结构体的大小为最大对齐数的整数倍
struct s
{
char a; //对齐数是1
int b; //对齐数是4
char c; //对齐数是1
}; //最大对齐数是4，因此结构体大小一定是4的整数倍
int main()
{
struct s s1={ 0 };
}因此答案是12，如图所示
| 0 a |
| 1 未使用 |
| 2 未使用 |
| 3 未使用 |
| 4 b |
| 5 b |
| 6 b |
| 7 b |
| 8 c |
| 9 未使用 |
| 10 未使用 |
| 11 未使用 |
这就是结构体变量s1在内存空间中的存储情况
练习：试着计算sizeof（struct A）的结果
struct A
{
double a;
char b;
int c;
}; //sizeof（struct A）是多少呢？
第一步：先计算每个成员变量的对齐数 ，将第一个成员变量存入偏移量为0的地址内
struct A
{
double a; //double占8个字节，vs默认对齐数为8，对齐数要取两者的较小值，因此该成员变量对齐数为8
char b; //对齐数为1
int c; //对齐数为4
};
| 假设从这开始存储，此处偏移量就为0，a变量就会存放在这里，又因为double占8个字节 |
| 0 a |
| 1 a |
| 2 a |
| 3 a |
| 4 a |
| 5 a |
| 6 a |
| 7 a double占8个字节 |
| 8 |
接着存放char类型的变量b和int类型的变量c，要把他们存放到对齐数的整数倍地址上，如图
| 0 a |
| 1 a |
| 2 a |
| 3 a |
| 4 a |
| 5 a |
| 6 a |
| 7 a |
| 8 b |
| 9 未使用 |
| 10 未使用 |
| 11 c |
| 12 c |
| 13 c |
| 14 c int占4个字节 |
| 15 |
| 16 |
又因为结构体的大小是最大对齐数的整数倍，因此结果为16
4.如果嵌套了结构体的情况，嵌套的结构体对齐到自己的最大对齐数的整数倍处，结构体的整体大小就是所有最大对齐数（含嵌套结构体的对齐数）的整数倍
struct A
{
double a;
char b;
int c;
};
struct B
{
char d;
struct A a;
double e;
}s; //sizeof(s)是多少呢？
| 0 假如从此处开始存储 ，此处偏移量为0，存放变量d |
| 1 |
| 2 |
| 3 |
| 4 |
接着存放结构体变量a，我们由上述练习可知
struct A
{
double a; //对齐数为8
char b; //对齐数为1
int c; //对齐数为4
};
最大对齐数是8，该结构体占16字节 ，因此要把该结构体变量a存放在地址为8的整数处
| 0 d |
| 1 未使用 |
| 2 未使用 |
| 3 未使用 |
| 4 未使用 |
| 5 未使用 |
| 6 未使用 |
| 7 未使用 |
| 8 a |
| 9 a |
| 10 a |
| 11 a |
| 12 a |
| 13 a |
| 14 a |
| 15 a |
| 16 a |
| 17 a |
| 18 a |
| 19 a |
| 20 a |
| 21 a |
| 22 a |
| 23 a |
接着存放double类型的变量e，对齐数是8，占8个字节
| 22 a |
| 23 a |
| 24 e |
| 25 e |
| 26 e |
| ~~~~~~~~~ |
| ~~~~~~~~~ |
| 31 e |
又因为结构体的大小是最大对齐数的整数倍
struct A
{
double a;
char b;
int c;
};
struct B
{
char d; //对齐数是1
struct A a; //对齐数是8
double e; //对齐数是8
}s; //最大对齐数是8，结构体变量大小是8的整数倍
答案是32
为什么存在内存对齐？
这个问题有两个原因
1.平台原因（移植原因）：不是所有的硬件平台都能访问任意地址上的任意数据；某些硬件平台只能在某些地址处取某些特定类型的数据，否则抛出硬件异常
2.性能原因：数据结构（尤其是栈）应该尽可能地在自然边界上对齐。原因是，为了访问未对齐的内存，处理器需要作两次内存访问；而对齐的内存访问仅需要一次访问
| 0 |
| 1 |
| 2 |
| 3 |
| 4 |
| 5 |
| 6 |
| 7 |
| 8 |
| 9 |
如：可能某些平台规定只能访问偏移量为4的倍数的地址，这就是平台原因
struct a
{
char b;
int c;
};假设计算机一次读取4个字节
| 假设从此处开始存储，则此处偏移量为0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 |
正确读法
| 0 b | 1 | 2 | 3 | 4 c | 5 c | 6 c | 7 c | 8 c | 9 | 10 |
假设计算机一次能读取4个字节，读取变量c，一次 便可完成
如果是这样
| 0 b | 1 c | 2 c | 3 c | 4 c | 5 | 6 | 7 | 8 | 9 | 10 |
读取变量c需要两次才能完成 ，这便是性能原因
总的来说，结构体的内存对齐是拿空间来换取时间的做法
如何做到在设计结构体时，既满足对齐，又节省空间？
方法1：让占用空间小的成员集中在一起
struct a1
{
char a;
int b;
char c;
};
struct a2
{
char a;
char c;
int b;
}; //sizeof(struct a1)和sizeof(struct a2)的结果分别是多少？答：a1和a2类型的成员一模一样，但是前者为12，后者为8，因为后者将char类型的成员变量放在一起，节省了空间
方法2：修改默认对齐数
使用#pragma这个预处理指令
#pragma pack(8) //修改默认对齐数为8
struct s
{
char c1;
int i;
char c2;
};
#pragma pack() //取消设置的默认对齐数，还原为默认那么下面这个结构体的大小是多少呢？
#pragma pack(2) //修改默认对齐数为2
struct s
{
char c1;
int i;
char c2;
};
#pragma pack() //取消设置的默认对齐数，还原为默认#pragma pack(2)
struct s
{
char c1; //char占1个字节，默认对齐数为2，取较小值，则该成员变量的对齐数为1
int i; //int占4个字节，默认对齐数为2，取较小值，则该成员变量的对齐数为2
char c2;
}; //最大对齐数是2
#pragma pack() 如图所示
| 0 c1 |
| 1 未使用 |
| 2 i |
| 3 i |
| 4 i |
| 5 i |
| 6 c2 |
又因为结构体大小只能是最大对齐数的整数倍，因此该结构体大小为2的倍数，即为8
结构在对齐不合适的时候，我们可以自己修改默认对齐数
位段
位段的声明
位段的声明和结构体的声明是类似的，但有两个不同
1.位段的成员必须是int、unsigned int或signed int(也有char类型，因为char也是整型家族中的一员，在内存中存储字符时存放的是字符的ASCII值）
2.位段的成员名后边有一个冒号和一个数字
比如下面
struct A
{
int a:2;
int b:5;
int c:10;
int d:30;
}; //位段的每一个成员后边有一个冒号和一个数字
//A就是一个位段类型 位段的大小
struct A
{
int a:2;
int b:5;
int c:10;
int d:30;
}; //sizeof（struct A）是多少呢？数字的含义
先来解释一下后面这些数字的含义
struct A
{
int a:2; //a成员占2个bit位
int b:5; //b成员占5个bit位
int c:10; //c成员占10个bit位
int d:30; //d成员占30个bit位
}; 位段成员的内存分配
然后我们来解释一下位段成员的内存分配
1.位段的成员可以是int、unsigned int或者是char（属于整型家族）类型
//一个例子
struct A
{
int a:2; //a成员占2个bit位
int b:5; //b成员占5个bit位
int c:10; //c成员占10个bit位
int d:30; //d成员占30个bit位
}; 2.位段的空间上是按照需要以4个字节（int）或者1个字节（char）的方式来开辟的
//一个例子
struct A
{
//首先开辟4个字节，32bit
int a:2; //a成员占2个bit位
int b:5; //b成员占5个bit位
int c:10; //c成员占10个bit位
//32个bit装下了成员a，b，c，用了17bit，剩下15bit不能存储30bit的成员d
//因此又开辟了4个字节（32bit）用来存放成员d
int d:30; //d成员占30个bit位
}; 由上可知我们一共开辟了8个字节，所以sizeof（struct A）的答案就是8
我们现在出现了一个问题
//一个例子
struct A
{
//首先开辟4个字节，32bit
int a:2; //a成员占2个bit位
int b:5; //b成员占5个bit位
int c:10; //c成员占10个bit位
//32个bit装下了成员a，b，c，用了17bit，剩下15bit不能存储30bit的成员d
//因此又开辟了4个字节（32bit）用来存放成员d
int d:30; //d成员占30个bit位
}; 成员d的30bit是全部存放在新开辟的32bit中，还是将15bit存放在先前剩下的空间，再将17bit存放在后来开辟的32bit中
3.位段涉及很多不确定因素，位段是不跨平台的，注重可移植的程序应该避免使用位段
C语言标准没有规定，是否舍弃先前剩下的15bit ，在不同平台的实现方式可能不同
空间是如何开辟的？
好啦，我们再来举一个例子说说位段成员的空间是如何开辟的(vs编译器)
struct s
{
char a:3;
char b:4;
char c:5;
char d:4;
} s1 = { 10, 12, 3, 4 };
我们知道，位段的空间上是按照需要以4个字节（int）或者1个字节（char）的方式来开辟的，
该位段的成员都是char类型，所以按照1个字节的方式来开辟
struct s
{
//首先开辟1个字节-8个bit，用来存放a和b，剩下1个bit不够存放占5个bit的c，因此
char a:3;
char b:4;
//开辟1个字节-8个bit，用来存放c，剩下3个bit不够存放占4个bit的d，因此
char c:5;
//开辟1个字节-8个bit，用来存放d，剩下4个bit
char d:4;
} ;
struct s s1 = { 0 };
s1.a = 10;
s1.b = 12;
s1.c = 3;
s1.d = 4;
如图所示
1.开辟1个字节，10的二进制是1010，占3个bit，取后三位先放在右侧（VS编译器中，位段成员在内存中从右向左分配）
| 00000010 |
2.12的二进制是1100，占4个bit，取4位接着放
| 01100010 |
3.剩下的1个bit不够存放c（c占5个bit） ，因此新开辟了1个字节-8个bit，用来存放3的二进制11，占5个字节，空位补0，因此存的是00011
| 01100010 | 00000011 |
4.剩下的3个bit不够存放d（d占4个字节），因此新开辟了1个字节-8个bit，用来存放4的二进制100，占4个bit，空位补0，因此存的是0100
| 01100010 | 00000011 | 00000100 |
这就是在vs编译器中，位段空间开辟的方式 （当然，这个代码不能正确存储a和b的值，这里只是讲解空间如何开辟）
位段的跨平台问题
1.int位段被当成有符号数，还是无符号数是不确定的
2. 位段中最大位的数目不能确定
//32位机器最大是32，16位机器最大是16 struct a { int a：40; //error }；3.位段中的成员在内存中从左向右分配，还是从右向左分配标准尚未定义
4.当一个结构包含两个位段，第二个位段成员比较大，无法容纳第一个位段剩余的位时，是舍弃剩余的位还是利用，这是不确定的
总结：跟结构相比，位段可以达到同样的效果，但是可以很好的节省空间，但存在跨平台的问题
1084
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
