----------------------------
------------------
岁月漫长心怀热爱，携手共赴星辰大海
--------今天来到我们自定义类型
-----结构体的讲解
目录
结构体的类型声明和初始化
结构体的类型声明
C语⾔已经提供了内置类型，如：char、short、int、long、float、double等，但是只有这些内置类型还是不够的，假设我想描述学生，描述⼀本书，这时单⼀的内置类型是不行的。描述⼀个学生需要名字、年龄、学号、身高、体重等；C语言为了解决这个问题，增加了结构体这种自定义的数据类型，让程序员可以自己创造适合的类型。
声明结构体类型时使用的关键字是struct，一般形式如下：
struct 结构体名
{
成员列表
};再声明结构体类型的时候不要忘记花括号后面的分号' ; '哦！
struct stu
{
char name[20];//名字
int age;//年龄
char sex[5];//性别
char id[20];//学号
}；上面的代码用struct申明了一个名为stu的结构体类型，在结构体中定义的变量是stu结构体内部的成员，这些成员表示名字，年龄， 性别，学号，可以根据结构体成员中不同的作用选择与其相对应的类型。
struct stu
{
char name[20];//名字
int age;//年龄
char sex[5];//性别
char id[20];//学号
}s,t;以上是在声明结构体的同时定义了变量s，t
结构体成员的直接访问
可以用struct+结构体名+变量名 = {成员列表};
对变量进行直接初始化
#include<stdio.h>
struct Stu
{
char name[20];//名字
int age;//年龄
char sex[5];//性别
char id[20];//学号
};
int main()
{
//按照结构体成员的顺序初始化
struct Stu s = { "张三", 20, "男", "2023101314" };
//按照自定义顺序初始化结构体成员
struct Stu t = { .sex = "男",.name = "李四",.id = "2023105201",.age = 19 };
printf("%s %d %s %s\n", s.name, s.age, s.sex, s.id);
printf("%s %d %s %s\n", t.name, t.age, t.sex, t.id);
return 0;
}也可以利用scanf函数进行输入：
#include<stdio.h>
struct Stu
{
char name[20];
int age;
char sex[5];
int id;
}s1;
int main()
{
scanf("%s", s1.name);//数组可以不用取地址&符号
scanf("%d", &s1.age);
scanf("%s", s1.sex);
scanf("%d", &s1.id);
printf("%s %d %s %d", s1.name, s1.id, s1.sex, s1.age);
return 0;
}数组的前面可以不用取地址符号（&）
因为数组本身就是地址
自定义初始化结构体成员只要 ' . ' 点一下就可以显示成员信息啦
结构体成员的直接访问是通过点操作符 ' . ' 访问的，点操作符接受两个操作数
使用方式：结构体变量.成员名
结构体成员的间接访问
我们可以用指向结构体的指针来访问成员变量
#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);
printf("x = %d y = %d\n", p.x, p.y);
return 0;
}1.我们这里定义了两个整形成员的结构体类型
2.并对结构体类型变量p成员赋值3，4
3.我们用指针ptr对结构体类型变量p取地址
4.利用结构体指针操作符（->）对结构体成员进行访问
使用方式：结构体指针->成员名
#include <stdio.h>
#include <string.h>
struct Stu //结构体类型
{
char name[15];//名字
int age; //年龄
};
void print_stu(struct Stu s) //打印函数
{
printf("%s %d\n", s.name, s.age);
}
void set_stu(struct Stu* ps)
{
strcpy(ps->name, "李四");//将李四拷贝到结构体变量的name的位置中
ps->age = 28; //利用指针访问结构体成员的age，并赋值
}
int main()
{
struct Stu s = { "张三", 20 };
print_stu(s); //打印未拷贝前的结构体成员张三
set_stu(&s); //传址调用
print_stu(s); //打印拷贝后的结构体成员李四
return 0;
}
嵌套结构体进行访问
当出现结构体嵌套时，必须以级联方式访问结构体成员，即通过成员选择运算符逐级找到最底层的成员时再引用
#include<stdio.h>
struct Str
{
int year;
int month;
int day;
};
struct Stu
{
char name[20];
int age;
char sex[5];
char id[20];
struct Str date;
};
int main()
{
struct Stu t = { .sex = "男",.name = "李四",.id = "2023105201",.age = 19 ,.date.year = 2023,.date.month = 12,.date.day = 1 };
printf("%s %d %s %s %d-%d-%d\n", t.name, t.age, t.sex, t.id, t.date.year, t.date.month, t.date.day);
return 0;
}
使用typedef来定义结构体
typedef struct
{
结构体成员列表;
}结构体别名;
与没有typedef的的定义的区别在于：
1.没有typedef的定义：struct Stu s = {结构体成员列表}；
2.typedef的定义：Stu s = {结构体成员列表}；
3.typedef可以省略struct这个关键字，做到简化代码
4.typede可以对匿名结构体重命名
typedef struct
{
char name[30];
int age[10];
}Stu;
int main()
{
Stu s = { .name = "张三",.age = "18" };
return 0;
}匿名结构体类型
声明结构体的时候，可以不完全声明
#include <stdio.h>
struct
{
int a;
char name;
int b;
float score;
}x;
struct
{
int a;
char name;
int b;
float score;
}*p;
int main()
{
*p = &x;
return 0;
}以上的结构体声明，省略了结构体名
假如我定义了两个相同结构体类型的变量x和指针p
那么我是否可以*p = &x呢？
答案是不可以的，因为结构体是匿名的，编译器会认为是两种不一样的类型
匿名的结构体类型，如果没有对结构体类型重命名的话，基本上只能使⽤⼀次
匿名结构体不建议大家使用的
不过也可以写来备用，到时候用typedef重命名就好啦
结构体的自引用
在结构中包含⼀个类型为该结构本⾝的成员是否可以呢？像以下代码
struct Stu
{
int a;
struct Stu;
};答案是不可行的，结构体的自引用不像函数递归可以直接自己调用自己
如果上述代码可行的话，那么sizeof(struct Stu)的大小是多少呢
因为⼀个结构体中再包含⼀个同类型的结构体变量，这样结构体变量的大小就会无穷的大，是不合理的所以要做到结构体的自引用，可以借用指针来实现
struct Stu
{
int a; //存放数据
struct Stu* next;//存放下一个节点的地址
//next-同类型的结构体指针
}; 
我们可以通过存放相同结构体类型的指针来完成自引用
这就是我们以后要学的数据结构中的链表
注意：
在结构体自引用的时候最好不要使用typedef对匿名结构体重命名
就像以下代码是不可行的
typedef struct
{
int a;
Stu* next;
}Stu;因为Stu是对前面的匿名结构体类型的重命名产⽣的，但是在匿名结构体内部提前使
用Stu类型来创建成员变量 ， 这是不行的
解决的办法是：要自引用时定义结构体不要使用匿名结构体
typedef struct Stu
{
int a;
struct Stu* next;
}Stu;qsort排序结构体
我们之前说到qsort可以对任意类型的数据排序
接来我们将用它来排序结构体
void qsort (void* base, size_t num, size_t size, int (*compar)(const void*,const void*));base首元素地址-数组名
num元素个数
size数据类型的大小
int (*compar)(const void*,const void*))比较大小的函数指针
以下我用qsort排序结构体的名字：
#include<stdio.h>
struct Stu
{
char name[20];
int age;
};
//strcmp-是库函数，是专门用来⽐较两个字符串的⼤⼩的（不懂可以看我之前的博客）
//假设按照名字来⽐较
int PaiXu(const void* e1, const void* e2)
{
return strcmp(((struct Stu*)e1)->name, ((struct Stu*)e2)->name);
//比较字符串的大小，返回>0或<0或=0的值
}
int main()
{
struct Stu s[] = { {"zhangsan", 20}, {"lisi", 30}, {"wangwu", 15} };
int rs = sizeof(s) / sizeof(s[0]);
qsort(s, rs, sizeof(s[0]), PaiXu);
for (int i = 0; i < rs; i++)
{
printf("%s %d\n", s[i].name,s[i].age);
}
return 0;
}
这是从小到大排序，从大到小排序可以通过交换两个指针的位置实现
于是我们可以发现结构体按照名字比较最大是zhangsan，最小是lisi
结构体的传参
函数的传参我们学过两种：
1.传值
2.传址
#include<stdio.h>
struct Stu
{
int a[1000];
int num;
};
struct Stu s = { {1,2,3,4},1314 };
void Print1(struct Stu s)
{
printf("%d %d\n", s.a[0],s.num);
}
void Print2(const struct Stu* s) //用const加以修饰指针说明s不可修改
{
printf("%d %d\n",s->a[0], s->num);
}
int main()
{
Print1(s); //传值
Print2(&s); //传址
return 0;
}以上我们发现无论是传值还是传址其结果都是一样的
但是空间、时间复杂度上是不一样的：
1.传值：比如说我结构体成员中定义了长度为1000的数组a[1000]，我的实参开辟了1000个存储空间，而传结构体的值过去我的形参也要开辟1000个存储空间，多的空间不用这就造成了空间上的浪费
2.传址：我们传结构体的地址过去，形参中就可以不用多开辟空间，效率就高。再加上可以利用const对结构体指针加以限制就可以避免对实参地址的破坏
1.函数传参的时候，参数是需要 压栈 ，会有 时间和空间上的系统开销 。2.如果传递⼀个结构体 对象的时候，结构体过大，参数压栈的的系统开销比较大 ，所以会导致性能的下降。
结构体内存对齐
首先得掌握结构体的对齐规则：
1. 结构体的第⼀个成员对⻬到和结构体变量起始位置偏移量为0的地址处
2. 其他成员变量要对齐到某个数字（对齐数）的整数倍的地址处
对齐数 = 编译器默认的⼀个对齐数与该成员变量大小的较小值
VS 中默认的值为 8
Linux中gcc没有默认对齐数，对齐数就是成员自身的大小
3. 结构体总大小为最⼤对齐数（结构体中每个成员变量都有⼀个对齐数，所有对齐数中最⼤的整数倍
4. 如果嵌套了结构体的情况，嵌套的结构体成员对齐到⾃⼰的成员中最⼤对⻬数的整数倍处，结构体的整体⼤⼩就是所有最⼤对⻬数（含嵌套结构体中成员的对⻬数）的整数倍
我们来看以下代码：
再没有学结构体内存对齐之前
大家对以下结构体的大小认识还不是还停留在：
两个char类型2个字节，一个int类型4个字节，结构体就是6个字节
看看S1和S2的大小是多少？
#include<stdio.h>
struct S1
{
char c1;
int i;
char c2;
};
struct S2
{
char c1;
char c2;
int i;
};
int main()
{
printf("%d\n", sizeof(struct S1));
printf("%d\n", sizeof(struct S2));
return 0;
}
我们发现S1和S2的大小并不是我们预想的6个字节
而是S1是12个字节，S2是8个字节
为什么呢？请你带着知识的困惑来看我们的结构体内存对齐：
以上是S1的情况，我们来看：
因为VS编译其中，默认对齐数是8，而(char)、(int)类型的大小是1和4
所以char的对齐数是1，int的对齐数是4，最大对齐数是4
char一个字节对齐起始位置偏移量为0的地址处
因为1到3地址不是int对齐数的整数倍所以要浪费空间
int要从4地址开始取地址，当char取了9地址的时候
由于结构体总大小要为最大对齐数的整数倍，所以要浪费空间到12地址
我们来看S2的情况：
因为VS编译其中，默认对齐数是8，而(char)、(int)类型的大小是1和4
所以char的对齐数是1，int的对齐数是4，最大对齐数是4
char一个字节对齐起始位置偏移量为0的地址处
因为2到3地址不是int对齐数的整数倍所以要浪费空间
int要从4地址开始取地址，取到8地址是结构体最大对齐数的整数倍
我相信聪明的你已经学会了，接下来看嵌套一个结构体的情况：
#include<stdio.h>
struct S2
{
char c1;
char c2;
int i;
};
struct S4
{
char c1;
struct S2 s2;
double d;
};
int main()
{
printf("%d\n", sizeof(struct S2));
printf("%d\n", sizeof(struct S4));
return 0;
}
因为VS编译其中，默认对齐数是8
而(char)、(double)、（S2）类型的大小是1、8、8
所以char的对齐数是1，double、S2的对齐数是8，最大对齐数是8
char一个字节对齐起始位置偏移量为0的地址处
嵌套的结构体成员对⻬到⾃⼰的成员中最⼤对⻬数的整数倍处
S2成员最大对齐数是4，所以1到3的空间要浪费，直到取到12地址
double要对齐所以要浪费13到15的空间，直到取到24
24是结构体最大对齐数的整数倍，所以结构体大小就是24
为什么存在内存对齐?
平台原因：
不是 所有的硬件平台 都能访问任意地址上的任意数据 的某些硬件平台只能在 某些地址处取某些特定类型的数据否则抛出硬件异常
性能原因：
数据结构(尤其是栈)应该 尽可能地在自然边界上对齐 ：原因在于， 为了访问未对齐的内存，处理器需要作两次内存访问 ；而 对齐的内存访问仅需要⼀次访问 ；符合的数据更快被CPU访问。假设⼀个处理器总是从内存中取8个字节，则地址必须是8的倍数。如果我们能保证将所有的double类型的数据的地址都对齐成8的倍数，那么就可以⽤⼀个内存操作来读或者写值了。否则，我们可能需要执行两次内存访问，因为对象可能被分放在两个8字节内存块中。
结构体的内存对齐是拿空间来换取时间的做法
让占⽤空间⼩的成员尽量集中在⼀起
#include<stdio.h>
struct S1
{
char c1;
int i;
char c2;
};
struct S2
{
char c1;
char c2;
int i;
};
int main()
{
printf("%d\n", sizeof(struct S1));
printf("%d\n", sizeof(struct S2));
return 0;
}#pragma改变编译器的默认对齐数
#include <stdio.h>
#pragma pack(1)//设置默认对⻬数为1
struct S
{
char c1;
int i;
char c2;
};
#pragma pack()//取消设置的对⻬数，还原为默认
int main()
{
printf("%d\n", sizeof(struct S));
return 0;
}
结构体在对齐方式不合适的时候，我们可以自己更改默认对齐数
结构体实现位段
结构体位段的声明
1.位段的成员必须是 int、unsigned int 或signed int ，在C99中位段成员的类型也可以
选择其他类型，char比较常见2.位段的成员名后边有⼀个冒号和⼀个数字
位段的作用：节省内存空间
struct A
{
int _a:2;
int _b:5;
int _c:10;
int _d:30;
};这时的A就是一个位段
我们来看一下，struct A的大小是多少？
#include <stdio.h>
struct A
{
int _a : 2;
int _b : 5;
int _c : 10;
int _d : 30;
};
int main()
{
printf("%d", sizeof(struct A));
return 0;
}首先我们要理解冒号后面的是什么
位段就是一个二进制位
冒号后面的数据的单位就是比特位
我们发现strcut A的大小是8，那么8代表什么呢 ？
我们来看，如果冒号后面的数据单位是比特位的话
那么struct A的大小就是47个比特位
一个整形4个字节就是32个比特位不够
两个整形就是8个字节就是64个比特位
所以8代表8个字节
如果我们按照原始的方法存储的话，4个整形就是16个字节
而我们位段只需要8个字节就可以了，节省了内存空间
位段的内存分配
所以位段很依赖编译器，我们来认识VS下的位段：
从右向左使用
如果剩余空间不够下一位成员使用就浪费
位段的跨平台性
1. int 位段被当成有符号数还是无符号数是不确定的2. 位段中最大位的数目不能确定。（16位机器最⼤16，32位机器最⼤32，写成27，在16位机器会出问题3. 位段中的成员在内存中从左向右分配，还是从右向左分配标准尚未定义4. 当⼀个结构包含两个位段，第二个位段成员比较大，无法容纳于第⼀个位段剩余的位时，是舍弃剩余的位还是利用，这是不确定的
总结：
跟结构相比，位段可以达到同样的效果
并且可以很好的节省空间，但是有跨平台的问题存在
位段的运用
能够对网络信息进行封装，从而提高运行效率。
下图是网络协议中，IP数据报的格式，我们可以看到其中很多的属性只需要几个bit位就能描述，这里使用位段，能够实现想要的效果，也节省了空间，这样网络传输的数据报大小也会较小⼀些，对⽹络的畅通是有帮助的。
位段使用的注意事项
位段的几个成员共有同⼀个字节，这样有些成员的起始位置并不是某个字节的起始位置，那么这些位置处是没有地址的。内存中每个字节分配⼀个地址，⼀个字节内部的bit位是没有地址的。 所以不能对位段的成员使用&操作符，这样就不能使用scanf直接给位段的成员输⼊值，只能是先输入放在⼀个变量中，然后赋值给位段的成员。
#incldue<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;
}
通过本篇博客
我相信大家对C语言结构体都有了一定的理解
希望这些知识可以运用在你的实际生活中
3605
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
