目录
前言
结构体
1含义
2语法
3匿名结构体
4结构体自引用
5结构体的定义与初始化
6内存对齐
7修改对齐数
8结构体传参
位段
1含义
2位段的内存分配
编辑3位段的问题
4位段的应用
枚举
1含义
2定义
3枚举优点
4枚举使用
联合
1含义
2定义
3特点
4计算
通讯录
前言
C语言的结构体知识学好了的话对后面学习C++类对象就简单很多了
结构体
1含义
结构体是一些值的集合，这些值称为成员变量；每个成员变量可以是不同类型的变量。
2语法
struct tag//类型名
{member-list;//成员变量
}variable-list;//可在此时定义出结构体类型的变量 它是全局变量假如我们用结构体来描述一个学生：
struct Stu
{char name[20];//名字int age;//年龄char sex[5];//性别char id[20];//学号
}S1;//分号不能丢3匿名结构体
也就是结构体不完全声明
//匿名结构体类型
struct
{int a;char b;float c;
}x;匿名结构体省略了tag(结构体类型名)，而且它只能用一次(声明后立即定义，不能声明后定义)
能否用指针来接收匿名结构体变量？
不能，编译器会认为这个两个类型（vs2019编都编不过，vs2022能编过！）
4结构体自引用
struct Node
{int data;struct Node next;
};int main()
{printf("%d", sizeof(struct Node));return 0;
}上面这种引用行吗？
编译器认为：你在内部定义了同一个结构体成员，那这个成员变量里又包含了同一个结构体成员...这个大小是
无穷大的
所以正确的结构体自引用
struct Node
{int data;struct Node* next;
};这种在链表中用的最多
其它的自引用定义：
typedef struct Node
{int data;N* next;
}N;这种写法是错误的：结构体typedef之前内部并不知道
//正确写法
typedef struct Node
{int data;struct Node* next;
}N;5结构体的定义与初始化
struct Poin
{int x;int y;
}p1 = {1,2};//可以在这里初始化struct stu
{int date;struct Poin p;
}s1;//全局变量int main()
{struct stu s2 = { 100,{20,30} };//局部变量 按顺序初始化//struct stu s2 = { .p={20,30},.date=100 };//指定成员初始化printf("%d %d %d\n", s2.date, s2.p.x, s2.p.y);return 0;
}6内存对齐
计算结构体的大小：这个非常重要的一个内容！！！
来看下面的一段代码：
struct s1
{char a;int b;char c;
};struct s2
{char a;char c;int b;
};int main()
{printf("s1的大小:%d\n", sizeof(struct s1));printf("s2的大小:%d", sizeof(struct s2));return 0;
}
int是4字节，char是1字节，两个int和一个char加起来不是6字节吗？
不同的结构体放着相同的变量，只是顺序不同，为什么大小不一样？
介绍一个宏：offsetof，用来查看结构体变量相对于内存的偏移位置
按照打印出来的内存偏移位置进行安排成员变量的放置
一共9个字节就能结束了，偏偏还要在浪费3个字节，前面也浪费3个字节，为什么？ 这时我们来看看内存对齐的规则：
1. 第一个成员在与结构体变量偏移量为0的地址处。
2. 其他成员变量要对齐到对齐数整数倍的地址处。
对齐数 = 编译器默认的一个对齐数 与 该成员大小的较小值
在VS中默认的值为8 而gcc是没有默认对齐数的
3. 结构体总大小为最大对齐数（每个成员变量计算出来的对齐数的最大值）的整数倍。
4. 如果嵌套了结构体的情况，嵌套的结构体对齐到自己的最大对齐数的整数倍处
结构体嵌套的结构体大小：
#include<stdio.h>struct S3//总大小：16
{double d;//8 8 -> 8char c; //1 8 -> 1int i; //4 8 -> 4
};
struct S4
{char c1; //1 8 -> 1struct S3 s3;//16 8 -> 8double d; //8 8 -> 8
};
int main()
{printf("%d\n", sizeof(struct S4));return 0;
}
那为什么存在内存对齐?
1. 平台原因(移植原因)：
可能硬件平台只能在某些地址处取某些特定类型的数据(否则硬件中断)；
2. 性能原因：
为了访问未对齐的内存，处理器需要作两次内存访问；而对齐的内存访问仅需要一次访问这本质上就是以空间换时间来提高效率！
那在设计结构体时：既要省空间，又要提高效率：
尽量让字节小的成员变量放在一起
#include<stdio.h>struct s1
{char c1;int i;char c2;
};struct s2
{char c1;char c2;int i;
};int main()
{printf("%d %d", sizeof(struct s1), sizeof(struct s2));return 0;
}
7修改对齐数
如果对应VS的默认对齐数不满意（最好不修改！），可以自己设定对齐数
#pragma pack(1)
//在#pragma的范围内的对齐数是1
struct s3
{char c1;int i;char c2;
};
#pragma()struct s4
{char c1;int i;char c2;
};int main()
{printf("s3=%d s4=%d", sizeof(struct s2), sizeof(struct s3));return 0;
}
8结构体传参
struct S
{int data[1000];int num;
};
struct S s = { {1,2,3,4}, 1000 };void print1(struct S s)
{printf("%d\n", s.num);
}void print2(struct S* ps)
{printf("%d\n", ps->num);
}int main()
{print1(s); //传结构体print2(&s); //传地址 //那种方式更优点？return 0;
}关于结构体传参，尽量使用传址传参：
因为一个结构体大小可能很大，如果传值传参会加大系统资源的开销，导致性能的下降；而使用传址传参时数据不希望进行修改，要把const加上！
位段
1含义
位段是一种特殊的自定义类型；
对空间的利用精打细算
a 位段的成员必须是 int、char(整形家族)；
b 位段的成员名后边有一个冒号和一个数字
struct A
{int _a : 2;int _b : 5;int _c : 10;int _d : 30;
};与结构体相比大小方面有什么不同吗？
struct A//如果是结构体
{int _a : 2;int _b : 5;int _c : 10;int _d : 30;
};struct B
{int _a;int _b;int _c;int _d;
};int main()
{printf("A=%d B=%d", sizeof(struct A),sizeof(struct B));return 0;
}
答案：位段比结构体大小要小，更节省空间了！那这是怎么实现的呢？
2位段的内存分配
位段后面的数字代表要分配多少个bit空间给该成员；
位段的空间是按照需要以4个字节（ int ）或者1个字节（ char ）的方式来开辟的
#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;
}
3位段的问题
1. int 位段被当成有符号数还是无符号数？
2. 位段中最大位的数目？（16位机器最大16，32位机器最大32，如果写成27，在16位机器会出问题）
3. 位段中的成员在内存中从左向右分配，还是从右向左分配？（在VS时从右向左）
4. 开辟的空间无法容纳下个位段时，是舍弃后另外开辟空间还是利用？（在VS时舍弃剩余的位）
4位段的应用
应用于各种协议（信息传到下一层时需要用到）
枚举
1含义
枚举就是一一列举；在现实生活中把一个星期进行枚举：星期一，星期二，星期三... 那么枚举怎么用代码来表示呢？
2定义
enum Day//星期
{Mon = 1,Tues,Wed,Thur,Fri,Sat,Sun
};enum Day是一个枚举类型；
枚举括号内的内容都是常量；
枚举默认从0开始（与数组一样）；但你也可以自己修改(Mon = 1)
3枚举优点
以上对于星期的枚举：我们也可以用#define Mon 1，#define Tues 2来表示，那是不是就说枚举就可以被替换了？
a 使用枚举方便调试（而#define在调试前就被替换成常量）；
b 枚举有类型检查，更严谨写；
b 使用枚举能增加代码的可读性与可维护性；
c 枚举内定义变量不存在命名冲突（而#define可能有命名污染问题）
4枚举使用
enum Color//颜色
{RED=1,GREEN=2,BLUE=4
};
int main()
{enum Color clr = GREEN;//只能拿枚举常量给枚举变量赋值，才不会出现类型的差异return 0;
}联合
1含义
联合也是一种特殊的自定义类型；
这种类型定义的变量也包含一系列的成员，这些成员公用同一块空间（所以联合也叫共用体）。
2定义
#include<stdio.h>
//联合类型的声明
union Un
{char c;int i;
};
int main()
{union Un un;printf("%d\n", sizeof(un));return 0;
}
3特点
a 由于联合类型共有内存空间，所以比其它的结构体而言节省空间；
b 成员共有内存空间，所以定义变量时成员不能同时出现（后一个会改变前一个的数据）
使用场景1：判断大小端（之前通过地址方式访问判断）
#include<stdio.h>
int sys_call()
{//匿名联合union{char c;int i;}Un;Un.i = 1;// 01 00 00 00 还是 00 00 00 01//(c与i公用1字节的内存空间)return Un.c;
}int main()
{if (sys_call()){printf("小端\n");}else{printf("大端\n");}return 0;
}使用场景2：设计一个礼物清单
struct git_list
{double price;char name[20];char author[20];int page;char form[20];double size;char flavour[20];char materials[20];
};//利用联合体设计清晰且省空间
struct git_list
{double price;char name[20];union{char author[20];int page;}book;union{char form[20];double size;}mug;union{char flavour[20];char materials[20];}cooike;
};4计算
a 联合的大小至少是最大成员的大小；
b 当最大成员大小不是最大对齐数的整数倍的时候，就要对齐到最大对齐数的整数倍；所以：联合大小 != 最大成员大小
#include<stdio.h>union Un1
{char c[5];int i;
};int main()
{printf("%d\n", sizeof(union Un1));return 0;
}你可能会因为大小是5(char c[5]一共是5字节，比i 4字节大)，但实际上：
最大是5没错，但它不是最大对齐数（max(char，int) = 4）的整数倍，进行要进行对齐
通讯录
实现一个通讯录，具备以下功能：
1增加联系人(名字，年龄，性别，电话，地址)；
2删除联系人的信息；
3查找联系人的信息；
4更改联系人的信息；
5打印通讯录；
6对通讯录进行排序；
//Contact.h
#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<assert.h>#define Max_Size 100
#define Max_NameSize 20
#define Max_SexSize 5
#define Max_CallSize 20
#define Max_AddrSize 30enum
{ext,add,del,check,modify,print,sort,
};typedef struct Mess
{char name[Max_NameSize];int age;char sex[Max_SexSize];char call[Max_CallSize];char addr[Max_AddrSize];
}Mess;typedef struct Contact
{int sz;Mess message[Max_Size];
}Contact;void Add(Contact* con);
void Del(Contact* con);
void Check(const Contact* con);
void Modify(Contact* con);
void Print(const Contact* con);
void Sort(Contact* con);//Contact.c
#include"contact.h"void Add(Contact* con)
{assert(con);if (con->sz == Max_Size){printf("Contact Is Full\n");return;}printf("Input Name:");gets(con->message[con->sz].name);//scanf("%s", &con->message[con->sz].name);printf("Input Age:");scanf("%d", &con->message[con->sz].age);//如果输入的是非法字符串?getchar();//清空缓冲区的'\n'printf("Input Sex:");gets(con->message[con->sz].sex);//scanf("%s", &con->message[con->sz].sex);printf("Input Call:");gets(con->message[con->sz].call);//scanf("%s", &con->message[con->sz].call);printf("Input Addr:");gets(con->message[con->sz].addr);//scanf("%s", &con->message[con->sz].addr);con->sz++;printf("Add Finish\n");
}void Print(const Contact* con)
{assert(con);if (con->sz == 0){printf("Contact Is Empty\n");return;}printf("%-20s %-5s %-5s %-11s %-30s\n", "name", "age", "sex", "call", "addr");for (int i = 0; i < con->sz; i++){printf("%-20s %-5d %-5s %-11s %-30s\n",con->message[i].name, con->message[i].age, con->message[i].sex,con->message[i].call,con->message[i].addr);}
}static int Find(const Contact* con,char Name[])
{for (int i = 0; i < con->sz; i++){if (strcmp(con->message[i].name,Name)==0)//用strcmp比{printf("Find Sucess\n");return i;}}printf("Find Error\n");return -1;
}void Del(Contact* con)
{assert(con);char InputName[Max_NameSize];printf("Input Del Name:");gets(InputName);int DelPos = Find(con, InputName);if (DelPos == -1) return;for (int i = DelPos; i < con->sz - 1; i++){con->message[i] = con->message[i + 1];//后一个往前一个覆盖}con->sz--;printf("Del Sucess\n");}void Check(const Contact* con)
{assert(con);printf("Input Check Name:");char Check_Name[Max_NameSize];gets(Check_Name);int pos = Find(con, Check_Name);if (pos == -1) return;printf("Check Result:\n");printf("%-20s %-5s %-5s %-11s %-30s\n", "name", "age", "sex", "call", "addr");printf("%-20s %-5d %-5s %-11s %-30s\n",con->message[pos].name, con->message[pos].age,con->message[pos].sex, con->message[pos].call,con->message[pos].addr);
}void Modify(Contact* con)
{assert(con);char Modify_Name[Max_NameSize];printf("Input Modify Name:");gets(Modify_Name);int pos = Find(con, Modify_Name);if (pos == -1) return;printf("Modify Name:");gets(con->message[pos].name);printf("Input Modify Age:");scanf("%d", &con->message[pos].age);getchar();printf("Input Modify Sex:");gets(con->message[pos].sex);printf("Input Modify call:");gets(con->message[pos].call);printf("Input Modify addr:");gets(con->message[pos].addr);printf("Modify Sucess\n");
}int cmp(const void* a, const void* b)
{return ((*((Contact*)a)).message->age - (*((Contact*)b)).message->age);
}void Sort(Contact* con)
{qsort(con, con->sz, sizeof(con->message[0]), cmp);printf("排序完成\n");
}//test.c
#include"contact.h"void memu()
{printf("********************************\n");printf("***** 0.exit 1.add *****\n");printf("***** 2.del 3.check *****\n");printf("***** 4.modify 5.print *****\n");printf("***** 6sort *****\n");
}int main()
{Contact con;//对con空间进行清理memset(&con, 0, sizeof(con));int input;do{memu();printf("Please Select:");//防止读到字符串时发生死循环input = 123456;//防止下一次输入的是字符后input还是上一次的值scanf("%d", &input);getchar();//输入字符串时:清空缓冲区的'\n'switch (input){case ext:printf("Process Exit");break;case add:Add(&con);break;case del:Del(&con);break;case check:Check(&con);break;case modify: Modify(&con);break;case print:Print(&con);break;case sort:Sort(&con);break;default:printf("Select Error,Please Try Again\n");break;}}while(input);return 0;
}但上面的通讯录无法做到：
通讯录满了无法再存信息(学习动态内存管理后解决)；
关闭程序时通讯录信息还存在(学习完文件操作后解决)；
以上便是全部内容，有问题欢迎在评论区指正，感谢观看！