目录
3.1结构体成员直接访问，通过(.)点操作符实现，点操作符接受两个操作数：
3.2结构体成员的间接访问，是通过得到一个指向结构体的指针，和（->）来实现的：
1.结构体类型声明
1.1结构体的声明
基本形式为
struct tag
{
member-list;
}variable-list;比如要描述一个学生的基本信息时，我们要表述ta的名字，性别，身高，年龄……，这些数据要放在一个整体上表述一个学生的基本信息，但这些数据类型不同，又不能存在同一个数组中。对于需要将不同类型数据归纳到一个整体中，就需要结构体这一类型。
比如对一个学生基本信息的描述：
struct stu
{
char name[20];
char gender[20];
int age;
double height;
}; //注意分号其中，name【20】，gender【20】，age，height为结构体成员变量，stuct stu为自定义的结构体数据类型。
结构是⼀些值的集合，这些值称为成员变量。结构的每个成员可以是不同类型的变量，如： 标量、数组、指针，甚至是其他结构体。
1.2结构体的特殊声明
在结构体声明时，可以不完全声明：
struct
{
int i;
int j;
}x;
struct
{
int i;
int j;
}*p;
P = &x;
在c++中编译器会把上面的两个声明当成完全不同的两个类型，所以p=&x，这一过程是非法的；
匿名结构体类型，如果没有对结构体重命名的话，基本只能使用一次；
1.3对匿名结构体类型进行重命名
类型重命名需要typedef，对匿名结构体类型进行重命名，就有了重名名称，实际上就不再匿名了，可以多次使用：
#include <stdio.h>
typedef struct
{
int i;
int j;
}newname;
int main()
{
newname s1 = { 1,2 };
newname s2 = { 3,4 };
printf("%d %d %d %d\n", s1.i, s1.j, s2.i, s2.j);//1 2 3 4
return 0;
} 
1.4结构的自引用
在结构体中包含一个类型为该结构本身的成员是否可行呢？
比如：
struct stu
{
int age;
struct stu a;
};语法上好像没什么问题，但理论上是错误的，因为sizeof（struct stu）就会无穷大，这是不合理的；
正确的自引用：
struct stu
{
int age;
struct stu* a;
};再来看看这段代码：
typedef struct
{
int age;
newname* a;
}newname;仔细思考一下，我们通过typedef对匿名结构体进行重命名，在进行结构自引用，逻辑上似乎没问题，但代码是按执行顺序进行的，在上面代码执行过程中，是先执行newname* a的，然后再重命名，这就与逻辑相违背了，所以是错的。所以在定义结构体最好不要用匿名结构体了。
2.结构体变量的创建和初始化
2.1结构体变量的创建
既然结构体是一种数据类型，那么就可以定义变量，结构体定义变量有两种方式：
#include <stdio.h>
struct stu
{
char name[20];
char gender[20];
int age;
double height;
}s1,s2; //直接在结构体声明时定义变量
int main()
{
struct stu s3; //在外部定义变量
struct stu s4;
return 0;
}2.2结构体变量的初始化
创建好变量后，就要往这些变量里面存放数据：
#include <stdio.h>
struct stu
{
char name[20];
char gender[20];
int age;
double height;
}s1,s2 = { "aoteman","secret",100,3.6 };
int main()
{
struct stu s3 = {"Ami","female",17,1.65};
struct stu s4 = {"Cookie","male",18,1.77};
return 0;
}上面是按照结构体声明是成员变量的顺序进行初始化的，也可以不按顺序进行初始化：
#include <stdio.h>
struct stu
{
char name[100];
char gender[100];
int age;
double height;
}s1, s2 = { "aoteman","secret",100,3.6 };
int main()
{
struct stu s3 = { "Ami","female",17,1.65 };
struct stu s4 = { "Cookie","male",18,1.77 };
struct stu s5 = {.age=34,.name = "tom",.gender = "male",.height=1.67};//不按顺序初始化
return 0;
}3.结构成员访问操作符
3.1结构体成员直接访问，通过(.)点操作符实现，点操作符接受两个操作数：
#include <stdio.h>
struct Point
{
int x;
int y;
}p = {1,2};
int main()
{
printf("x: %d y: %d\n", p.x, p.y);
return 0;
} 
3.2结构体成员的间接访问，是通过得到一个指向结构体的指针，和（->）来实现的：
#include <stdio.h>
struct Point
{
int x;
int y;
};
int main()
{
struct Point p = {3, 4};
struct Point *ptr = &p;
ptr->x = 10;
ptr->y = 20;
printf("x = %d y = %d\n", ptr->x, ptr->y);
return 0;
} 
4.结构体内存对齐
通过上述学习，我们基本掌握了结构体的使用方法了
现在来思考一个问题：如何计算结构体的大小
这就要涉及结构体对齐了
4.1对齐规则
1.结构体的第一个成员对齐到和结构体变量起始位置偏移量为0的地址处；
2.其他成员变量要对齐到某一数字（对齐数）的整数倍的地址处；
对齐数=编译器默认的一个对齐数与该成员变量大小的较小值。（vs默认为8，Linux中gcc没有默认对齐数，对齐数就是成员自身的大小）
3.结构体总大小为最大对齐数（成员变量中最大的对齐数）的整数倍。
4.如果出现嵌套结构体，嵌套的结构体要对齐到自己的成员中最大对齐数的整数倍，结构体的整体大小就是所有最大对齐数（含嵌套的结构体中成员的对齐数）的整数倍。
来几道题练练手：
#include <stdio.h>
struct stu
{
int a;
char b;
int c;
}x;
int main()
{
printf("%zu\n", sizeof(struct stu));
printf("%zu\n", sizeof(x));
return 0;
} 
按照对齐数规则即可求出结构体的大小；
看看这题：
#include <stdio.h>
struct stu
{
char b;
int a;
int c;
}x;
struct s1
{
int i;
short k;
struct stu j;
};
int main()
{
printf("%zu\n", sizeof(struct stu));
printf("%zu\n", sizeof(x));
printf("%zu\n", sizeof(struct s1));
return 0;
}前面两个跟前面一样，我们来讨论struct s1的大小：
4.2为什么要有内存对齐的概念呢？
内存对齐是为了提高内存访问的效率。当数据结构或变量在内存中按照其自然对齐的方式存储时，CPU可以更快地访问这些数据，因为它们可以直接对齐的内存地址进行读取或写入操作，而不需要额外的处理。此外，一些硬件架构要求数据按照特定的对齐方式存储，否则可能会导致性能下降或者错误（移植原因）。因此，内存对齐是为了提高内存访问效率和满足硬件要求而存在的。
总的来说，结构体的内存对齐是拿空间来换取时间的。
但在设计结构体时，我们要尽可能追求满足对齐，又要节省空间，那就要做到：让占用空间小的成员尽量集中在一起，如：
#include <stdio.h>
struct s1
{
char i;
int j;
char k;
};
struct s2
{
char i;
char k;
int j;
};
int main()
{
printf("%zu\n", sizeof(struct s1));
printf("%zu\n", sizeof(struct s2));
return 0;
}
4.3修改默认对齐数
使用预指令#pragma可以改变编译器的默认对齐数。
#include <stdio.h>
#pragma pack(1)//设置默认对⻬数为1
struct S
{
char c1;
int i;
char c2;
};
#pragma pack()//取消设置的对⻬数，还原为默认
struct S1
{
char c1;
int i;
char c2;
};
int main()
{
//输出的结果是什么？
printf("%d\n", sizeof(struct S));
printf("%d\n", sizeof(struct S1));
return 0;
}
5.结构体传参
传参一般分为两种：传值和传址
先看代码：
#include <stdio.h>
struct s
{
int a;
int arr[100];
};
void print1(struct s i)
{
printf("%d\n", i.a);
}
void print2(struct s* p)
{
printf("%d\n", p->a);
}
int main()
{
struct s i = { 1000,{1,2,3,4,5,6} };
print1(i);
print2(&i);
return 0;
}看起来似乎没什么差异，同样实现了对变量i的成员a的访问，但实际上，在传参过程中会有差异：
我们知道，传值过程中，是将实参的信息传递给形参，形参是实参的临时拷贝，因为传参是需要压栈的，会有时间和空间上的开销，如果结构体的成员比较大（如上面的arr【100】），则开销就越大，导致性能下降。
而传址过程中，传的是地址，形参实例化在系统上的开销只需要4/8个字节，需要访问结构体时，只需要用访问操作符（->）就可以了。
所以，传参结构体时一般用地址传参。
6.结构体实现位段
6.1什么是位段？（不是段位( ‘-ωก̀ )）
首先，位段时基于结构体的，是一种数据类型，用于在一个字节或更少的空间中存储多个不同长度的数据字段（可以理解成数据在同一块内存中）。它允许程序员将一个字节中的每个位都用作一个独立的布尔值或整数值，从而最大限度地利用存储空间。位段通常用于嵌入式系统和低级编程中，以便在有限的资源下实现高效的数据存储。
6.2位段的声明
位段的声明和结构体类似，有两个不同点：
1.位段的成员必须是 int、unsigned int ,char 或signed int ，在C99中位段成员的类型也可以选择其他类型。
2.位段的成员名后边有⼀个冒号和⼀个数字。
struct S
{
int _a:2;
int _b:5;
int _c:10;
int _d:30;
};冒号后面的数字表示的是bit位，表示成员所占有的内存空间大小，a分配了2个bit位，可表示的数值范围为0~3，当我们想要a成员只需要表示0~3之间的数时，使用位段形式可以节省需要开辟的空间大小，而不是开辟4个字节（32个bit位）去存储0~3的数。
位段成员名后面的冒号和数字可以同时去掉，此时表示原来类型分配的大小；
S就是一个位段类型，我们可以想想，这个位段类型大小是多少？位段类型的大小如何计算？
6.3位段的内存分配
1. 位段成员是int，unsigned int，signed int或者char等类型；
2.位段空间上是按照需要4个字节（int）或者1个字节（char）的方式来开辟的；
3.位段涉及很多不确定因素，比如位段在内存中是从左向右分配的，还是从右向左分配的标准尚未定义；当一个结构有两个及以上位段时，第二个位段比较大时，无法容纳于第一个位段剩余的位时，是舍弃剩下的位再开辟一段空间还是利用起来，这也是未定义的。所以位段说不跨平台的，移植性差，注重可移植性的程序应避开使用位段。
下面我们以vs2022举例子（从右向左，剩余丢弃重新开辟）：
#include <stdio.h>
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;
printf("%x\n", *(char*)&s);
printf("%x\n", *((char*)&s + 1));
printf("%x\n", *((char*)&s + 2));
printf("%x\n", *((char*)&s + 3));
return 0;
}将结构体的地址强转位（char*）类型，每次访问一个字节，观察每个字节数值的大小：
要怎么理解这串数字呢？
跟据这幅图，struct S的大小就显而易见了
6.4位段的跨平台问题
1.int 位段被当成有符号数还是⽆符号数是不确定的。
2.位段中最大位的数目不能确定。（16位机器最大16，32位机器最大32，写成27，在16位机器会 出问题。
3.位段中的成员在内存中从左向右分配，还是从右向左分配标准尚未定义。
4. 当一个结构包含两个位段，第二个位段成员⽐较大，无法容纳于第⼀个位段剩余的位时，是舍弃
6.5位段使用的注意事项
好了，以上就是本期的全部内容，如果对你有帮助的话，麻烦给个三连，如果文章存在错误或者需要补充的欢迎评论区留意，我们下期再见，拜拜！ヾ(≧▽≦*)o
扫一扫
598
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
