目录
在c语言中除了像int，char，float，long，double等本身支持的、现成的类型，也有自定义类型，比如说结构体struct、联合体union、枚举enum，接下来我们详细说一下结构体类型
1.结构体类型的声明
1.1 结构体变量的创建和初始化
结构是一些值的集合，这些值称为成员变量，结构的每个成员可以是不同类型的变量,下面是基本结构
struct tag
{
member - list; //成员，一个或多个
}variable-list; //变量名看不明白没关系，我们来举个例子，比如一个学生
struct student
{
char name[20];//名字
int age;//年龄
char sex[5];//性别
char id[20];//学号
};//这里有分号，不能忘了注意几点：
1.struct后面的student命名只要是符合语法的都可以
2.分号前面、反大括号后面的variable-list可以不在此处创建变量，后面再创建，在此处创建的话就是全局结构体变量，后面再创建的话就是局部的结构体变量，如下
#include <stdio.h>
struct student
{
char name[20];//姓名
int age;//年龄
char sex[5];//性别
char id[20];//学号
};
int main()
{
struct student s1; //s1为局部变量
return 0;
}或者
struct student
{
char name[20];
int age;
char sex[5];
char id[20];
}s1;//s1为全局变量这里很容易理解错误，误以为struct是变量类型，student是变量，其实并非这样
比如说你定义一个 int a；int是变量类型，a是变量，同理 struct student是结构体变量类型，s1才是结构体变量
再举个例子，比如一本书
struct book
{
char name[20];//书名
char author[20];//作者
float price;//价格
char id[10];//书号
}s2,s3,s4;struct book是结构体变量类型，s2，s3，s4都是结构体变量，且是全局变量
当然也可以像下面这样定义，这时s2，s3，s4[5]是局部变量，s4[5]是结构体数组
#include <stdio.h>
struct book
{
char name[20];//书名
char author[20];//作者
float price;//价格
char id[10];//书号
};
int main()
{
struct book s2;
struct book s3;
struct book s4[5];
return 0;
}变量创建好之后我们来进行初始化，以上面的struct book s2为例
struct book s2 = { "wodeshu","lingyangjiao",18.8,"A1010" };结构体初始化写在{}里面，书名、作者，书号是字符串，就用""初始化，价格是float类型，就直接写，中间用逗号隔开，我上面初始化的内容都是我随便写的，这种初始化是按照顺序依次初始化
也可以不按顺序，比如下面的代码
struct book s3 = { .id = "B2020",.author = "lingyangjiao",.name = "woxiedeshu",.price = 19.9 };不按顺序的话就要用一个点（.）操作符来找结构体成员，然后用 = 赋值就行了，中间用逗号隔开
如何将这些内容打印出来呢？接着往下看
#include <stdio.h>
struct book
{
char name[20];//书名
char author[20];//作者
float price;//价格
char id[10];//书号
};
int main()
{
struct book s2 = { "wodeshu","lingyangjiao",18.8,"A1010" };
printf("%s %s %f %s\n", s2.name, s2.author, s2.price, s2.id);
return 0;
}这是一种打印方法，用点（.）操作符： 结构体变量名.结构体成员
还有一种就是箭头（->）操作符： 结构体指针->结构体成员，如下，p是结构体指针
struct book* p = &s2;
printf("%s %s %f %s\n", p->name, p->author, p->price, p->id);1.2 结构的特殊声明
在声明结构的时候可以不完全声明，叫匿名结构体类型
比如
//不匿名
struct s
{
char c;
int i;
float f;
};
//匿名
struct
{
char c;
int i;
float f;
};这样的话这个结构体没有名字，定义变量的时候就不可以像下面这样
struct s//正常情况
{
char c;
int i;
float f;
};
struct //匿名情况
{
char c;
int i;
float f;
};
int main()
{
struct s S;//正常情况创建变量S
struct S;//匿名结构体不可以这样创建S
return 0;
}应该像下面这样创建
struct //匿名情况
{
char c;
int i;
float f;
}S;同时可以对它进行初始化
struct //匿名情况
{
char c;
int i;
float f;
}S = { 'x', 10, 3.14 };打印出来看看
#include <stdio.h>
struct //匿名情况
{
char c;
int i;
float f;
}S = { 'x', 10, 3.14 };
int main()
{
printf("%c %d %f", S.c, S.i, S.f);
return 0;
}现在这个类型没有名字，匿名了，所以匿名结构体只能用一次 ，但不是销毁
现在我们来思考一个问题，下面的代码可以这样写吗？
#include <stdio.h>
struct
{
char c;
int i;
float f;
}s;
struct
{
char c;
int i;
float f;
}* ps;
int main()
{
ps = &s;
return 0;
}答案是不可以的，因为这个匿名结构体没有名字，编译器无法确认s和指针ps类型是否一致
所以，匿名结构体是可以用的，也是存在的，但是使用很局限
1.3 结构体的自引用
大家可能或多或少听说过链表
我们把每一个框称为一个节点，这个节点不仅携带了值，还需要携带能找到下一个节点的信息，所以要把这样一个节点分为两部分，一部分存放值，一部分存放下一个结点的信息
存放下一个结点的信息时，可以像下面这样吗？
struct Node
{
int a;
struct Node next;
};答案是不可以。为什么不可以呢？想一下这样包含的话 sizeof(struct Node)的大小是多少呢？自己包含自己，无穷下去，最终能算出结构体大小吗？不能。那我们应该怎么做？
既然我们只是为了找到下一个节点，那我们存放下一个节点的地址就好了，最后一个节点放空指针NULL
struct Node
{
int a;//数据
struct Node* next;//指针，大小为4个字节
};这样就实现了结构体自己包含自己，也就是结构体的自引用（匿名的结构体不能实现结构体的自引用）
2.结构体内存对齐
看下面的代码，s的大小是多少？
#include <stdio.h>
struct S
{
char c1;
int i;
char c2;
};
int main()
{
struct S s = { 0 };
printf("%zd\n", sizeof(s));
return 0;
}char占1个字节，int占4个字节，char再占一个字节，大小为6，是不是呢？
显然不是，结果为12， 这是为什么呢？ 接下来我们就说说结构体的内存对齐
2.1 对齐规则
规则1
结构体的第一个成员对齐到结构体变量起始位置偏移量为0的地址处
规则2
其他成员要对齐到某个数字（对齐数）的整数倍的地址处
对齐数：编译器默认的对齐数 与 成员变量的大小的较小值
--vs默认对齐数是8
--Linux中gcc没有默认对齐数，所以对齐数就是成员自身大小
i的对齐数是4，从4的倍数的偏移量开始存4个字节，c2的对齐数是1，从1的倍数开始存1个字节
规则3
结构体总大小为结构体中所有成员对齐数的最大对齐数的整数倍
s中的成员最大对齐数是成员i的对齐数，为4，所以结构体的大小为4的倍数，当前大小为9，不是4的倍数，往后数，直到12，是4的倍数，所以结构体大小为12个字节，打红色X的空间都是被浪费掉的，为什么要浪费，我们后面讨论
对前三个规则的练习
1.算结构体大小
struct s2
{
char c1;
char c2;
int i;
};画图表示
结果是8个字节
2. 算结构体大小
struct s3
{
double d;
char c;
int i;
};依然是画图
为16个字节
3.算结构体大小，这里的struct s3就是上一题的struct s3
struct s4
{
char c1;
struct s3 S;
double d;
};还是画图
c1放好之后，嵌套的结构体S应该怎么放呢？我们先来看看第4个规则
规则4
如果结构体嵌套了结构体，嵌套的结构体成员对齐到自己的成员中最大对齐数的整数倍处，结构体的整体大小就是所有对齐数的最大值（包括嵌套结构体的对齐数）的整数倍
S中的最大对齐数是8，所以S要对齐到8的倍数
那么这个结构体的大小是不是就是32呢？是的
2.2 为什么存在内存对齐
那么在设计结构体中，我们既要对齐，又节省空间的话，应该怎么做？
让占用空间小的成员尽量集中在一起
比如
struct s1
{
char c1;
int i;
char c2;
};
struct s2
{
char c1;
char c2;
int i;
};虽然两个结构体成员完全一样，但是画图分析就可以知道内存区别
2.3 修改默认对齐数
用 #pragma 这个预处理指令，改变编译器的默认对齐数
没修改之前，下面这个代码结果应该为12，这个结构体的大小是12
#include <stdio.h>
struct S
{
char c1;
int i;
char c2;
};
int main()
{
printf("%zd", sizeof(struct S));
return 0;
}
我们用 #pragma pack（n）修改默认对齐数，要修改的值n放在（）里
#include <stdio.h>
#pragma pack(1) //默认对齐数设为1
struct S
{
char c1;
int i;
char c2;
};
#pragma pack() //取消修改，括号中不放数
int main()
{
printf("%zd", sizeof(struct S));
return 0;
}结果应该是6
3.结构体传参
现在需要写一个函数来打印结构体里面的内容，这个函数应该怎么传参？参数应该怎么设计？
#include <stdio.h>
struct S
{
int arr[1000];
int n;
double d;
};
int main()
{
struct S s = { {1,2,3,4,5},100,3.14 };//初始化
printf1();//负责打印的函数
return 0;
}
看下面的函数可以实现吗
void printf1(struct S t) //传值
{
int i = 0;
for (i = 0; i < 5; i++)
{
printf("%d ", t.arr[i]); //打印数组
}
printf("%d ", t.n);//打印n
printf("%lf ", t.d);//打印d
}printf1(s);当代码运行起来的时候是可以打印出来的
但是，这是传值调用，这意味着S有多大空间，t就有多大空间，一个数组arr[1000]就占了4000个字节，而这么多的内存还要开辟两次，可想而知，很浪费空间，并且浪费时间，那怎么传呢？传地址过去就好了
printf2(&s);void printf2(struct S * t)
{
int i = 0;
for (i = 0; i < 5; i++)
{
printf("%d ", t->arr[i]); //打印数组
}
printf("%d ", t->n);//打印n
printf("%lf ", t->d);//打印d
}用结构体指针t接收s的地址，聪明的同学已经发现，t的类型改为结构体指针后，打印结构体的时候操作符也变了，从 点（.）操作符： 结构体变量名.结构体成员 变成了 箭头（->）操作符： 结构体指针->结构体成员
所以，结构体传参的时候尽量传地址，如果害怕传址调用函数会改变结构体的值，在*前加一个const修饰就好了
void printf2(const struct S * t)4.结构体实现位段
4.1 什么是位段
位段是基于结构体的，位段的声明和结构类似，但有两点不同
1.位段成员必须是int（char）、unsigned int、signed int，在C99中位段成员类型也可以选项其他类型
2.位段成员名后面有一个冒号和数字，然后再加分号
比如
struct S1 //位段
{
int _a : 2;
int _b : 5;
int _c : 10;
int _d : 30;
};
struct S2 //结构体
{
int _a;
int _b;
int _c;
int _d;
};这就是位段式的结构 ，成员名命名合法即可，不一定要加下划线（_）
在结构体s2中，一个int占4个字节，32个bit位，假如现在我们在成员_a中存放的值只有0、1、2、3这样的数，一个数就只占了两个bit位，给_a 32个bit位的话会浪费30个bit位。
位段式s1中 int _a : 2; 这句的意思就是，_a只占两个bit位，同理，_b就只占5个bit位，_c占10个bit位，_d就占30个bit位
位段的应用场景就是这种，指定成员所占bit位，节省内存
那么s1的大小现在是多少字节呢？思考一下，我们稍后揭示
4.2位段的内存分配
1.位段的空间上是按照需要，以4个字节（int）或1个字节（char）的方式开辟的，不够用再开辟
2.位段有很多不确定因素，不可跨平台
我们先来看一段代码
#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;
return 0;
}为了演示我们一次一次开辟空间，首先开辟第一个成员char应该占的字节大小，1个字节
开辟好之后，位段中 a占3个bit位，从这4个字节的左边先使用还是右边呢？在vs中默认是从右向左使用，如图
然后就存放b，b占4个bit位，这一个字节还剩下5个bit位，够b使用，继续存放在这个空间中，如图
现在还剩1个bit位，c需要5个bit位，这个剩下的1个空间浪费还是继续使用？在vs中，会浪费这1个bit位，并且再申请一个字节空间，如图
现在第二个字节还剩3个bit位，而d需要4个字节，还是一样，把这3个浪费掉，重新开辟一个字节，如图
现在成员内存空间就开辟完了，我们一共申请了3个字节
现在开始存放数据
我们把s1初始化为0了，现在里面的每个bit位都是0，我们一个一个看，先看a
a赋值为10，10的二进制数后8个为 00001010，但是a的位置只有3个bit位，只能存3个，存的是后3位，也就是 010 ，如图
b赋值为12，12的二进制数后8个为 00001100 ，b只有4个bit位，所以存1100，如图
c赋值为3，2的二进制数后8个为00000011，c有5个bit位，所以存00011，如图
d赋值为4，4的二进制数后8个是00000100，d有4个bit位，所以存0100，如图
其余位置放0
4个二进制位换一个16进制位，所以最后的结果用16进制表示就是0x620304
0110 0010 0000 0011 0000 0100 //二进制
6 2 0 3 0 4 //16进制
我们打开调试窗口看对不对
结果完全正确
我们再回过头来看4.1中 s1 的内存
struct S1
{
int _a : 2;
int _b : 5;
int _c : 10;
int _d : 30;
};画图看看就可以知道，s1占了8个字节
本次分享就到这里，感谢阅读！
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
