该文章Github地址：https://github.com/AntonyCheng/c-notes
在此介绍一下作者开源的SpringBoot项目初始化模板（Github仓库地址：https://github.com/AntonyCheng/spring-boot-init-template & CSDN文章地址：https://blog.csdn.net/AntonyCheng/article/details/136555245），该模板集成了最常见的开发组件，同时基于修改配置文件实现组件的装载，除了这些，模板中还有非常丰富的整合示例，同时单体架构也非常适合SpringBoot框架入门，如果觉得有意义或者有帮助，欢迎Star & Issues & PR！
上一章：由浅到深认识C语言（10）：字符串处理函数
11.结构体
概念以及定义：
C 语言允许用户自己指定这样一种数据结构，它由不同类型的数据组合成一个整体，以便引用，这些组合在一个整体中的数据是互相联系的，这样的数据结构称为结构体，它相当于其它高级语言中记录；
11.1.结构体定义形式
**形式一：**先定义结构体类型，再定义变量（推荐）；
c
//定义结构体类型
struct 结构体类型{
成员一;
成员二;
......
};
//定义变量
struct 结构体类型 变量名;示例如下：
c
struct stu{
int id;
char name[5];
int age;
};
struct stu s1;此时结构体的数据类型就是定义时中括号前的内容，即 struct stu；
**形式二：**定义类型的同时定义变量；
c
//定义类型，同时定义变量
struct 结构体类型{
成员一;
成员二;
......
}变量名;示例如下：
c
struct stu{
int id;
char name[5];
int age;
}s1;**形式三：**定义一次性结构体；
c
//定义类型，但不带结构体类型，同时定义变量
struct {
成员一;
成员二;
......
}变量名;示例如下：
c
struct{
int id;
char name[5];
int age;
}s1;不能用一次性结构体定义其他变量，例如 s2 、s3 ......
注意事项
- 定义结构体类型的时候，不要给成员变量赋值，因为定义结构体类型的时候并没有分配空间，所以结构体类型不占空间，结构体变量才占空间；
- 结构体内的成员拥有独立的空间；
- 定义结构体类型是一条语句，所以要记住结构体后的那一个
;；
实例展示
c
#include<stdio.h>
struct stu
{
int id;
char name[32];
int age;
};
void test() {
printf("sizeof(struct stu) = %d\n", sizeof(struct stu));
return;
}
int main(int argc, char* argv[]) {
test();
return 0;
}打印效果如下：
11.2.结构体使用法则
格式：类似于Java中类的思想；
结构体变量.结构体成员
访问结构体成员时是通过结构体变量来访问的，而且一定要遵循成员自身的类型；
重点又是字符串在结构体中的操作，字符串除了初始化能够直接赋值之外，其他情况的赋值必须想其他方法，而在结构体中是不能在结构体中成员进行初始化的，所以我们就要将字符串拷贝进去；
示例如下：
c
#include<stdio.h>
#include<string.h>
struct stu
{
int id;
char name[32];
int age;
};
void test() {
struct stu xiaochen;
xiaochen.id = 9;
strcpy_s(xiaochen.name, 32, "晓晨");
xiaochen.age = 21;
printf("xiaochen.id = %d\n", xiaochen.id);
printf("xiaochen.name = %s\n", xiaochen.name);
printf("xiaochen,age = %d\n", xiaochen.age);
return;
}
int main(int argc, char* argv[]) {
test();
return 0;
}打印效果如下：
11.3.结构体的操作
初始化结构体
定义结构体类型的时候我们是不能将其初始化的，但是在定义变量时可以对其进行初始化；
初始化示例如下：
c
struct stu{
int id;
char name[32];
char sex;
};
struct stu s = {2020510,"xiaochen",'男'};清空结构体
格式如下：
c
struct stu{
int id;
char name[32];
char sex;
};
struct stu s = {2020510,"xiaochen",'男'};
memset(&s, 0, sizeof(s));11.4.结构体变量操作
获取键盘输入
示例如下：
c
#include<stdio.h>
#include<string.h>
struct stu
{
int id;
char name[32];
int age;
};
void test() {
struct stu xiaochen;
memset(&xiaochen, 0, sizeof(xiaochen));
printf("从键盘输入xiaochen的基本情况：");
scanf_s("%d %s %d", &xiaochen.id, xiaochen.name, 32, &xiaochen.age);
printf("xiaochen.id = %d\n", xiaochen.id);
printf("xiaochen.name = %s\n", xiaochen.name);
printf("xiaochen.age = %d\n", xiaochen.age);
}
int main(int argc, char* argv[]) {
test();
return 0;
}打印效果如下：
变量之间的赋值
例如此时有两个结构体变量，我们想将其中一个的值复制给另外一个，此时就要使用到变量之间的赋值运算；
**方式一：**逐个成员更换；
c
#include<stdio.h>
#include<string.h>
struct stu
{
int id;
char name[32];
int age;
};
void test() {
struct stu s1 = { 2022,"小红",21 };
struct stu s2;
s2.age = s1.age;
s2.id = s1.id;
strcpy_s(s2.name, 32, s1.name);
printf("s2.age = %d , s2.id = %d , s2.name = %s\n", s2.age, s2.id, s2.name);
}
int main(int argc, char* argv[]) {
test();
return 0;
}打印效果如下：
**方式二：**相同类型的结构体变量可以整体赋值；（推荐）
c
#include<stdio.h>
#include<string.h>
struct stu
{
int id;
char name[32];
int age;
};
void test() {
struct stu s1 = { 2022,"小红",21 };
struct stu s2;
s2 = s1;
printf("s2.age = %d , s2.id = %d , s2.name = %s\n", s2.age, s2.id, s2.name);
}
int main(int argc, char* argv[]) {
test();
return 0;
}打印效果如下：
**方式三：**使用内存拷贝函数 memcpy() 从原理出发实现赋值；
c
#include<stdio.h>
#include<string.h>
struct stu
{
int id;
char name[32];
int age;
};
void test() {
struct stu s1 = { 2022,"小红",21 };
struct stu s2;
memcpy(&s2, &s1, sizeof(s1));
printf("s2.age = %d , s2.id = %d , s2.name = %s\n", s2.age, s2.id, s2.name);
}
int main(int argc, char* argv[]) {
test();
return 0;
}打印效果如下：
11.5.结构体数组操作
结构体数组本质就是装有结构体的数组容器；
图解：
当我们要去提取 arr[2] 中的 name ，即用 arr[2].name ；
示例如下：
c
#include<stdio.h>
#include<string.h>
struct stu
{
int id;
char name[32];
int age;
};
void test() {
struct stu arr[5] = {
{100,"xiaofa",18},
{101,"xiaohong",19},
{102,"xiaowang",18},
{103,"xiaochen",19},
{104,"xiaowu",20}
};
for (int i = 0; i < 5; i++) {
printf("arr[%d].id = %d , arr[%d].name = %s , arr[%d].age = %d\n",i,arr[i].id,i,arr[i].name,i,arr[i].age);
}
}
int main(int argc, char* argv[]) {
test();
return 0;
}打印效果如下：
结构体数组从键盘输入：
c
#include<stdio.h>
#include<string.h>
struct stu
{
int id;
char name[32];
int age;
};
void test() {
struct stu arr[5];
int n = sizeof(arr) / sizeof(arr[0]);
memset(arr, 0, sizeof(arr));
printf("请一次输入%d个学生的学号，名字以及年龄：\n", n);
for (int i = 0; i < n; i++) {
printf("请输入第%d个学生的信息：\n",i+1);
scanf_s("%d %s %d", &arr[i].id, arr[i].name, 32, &arr[i].age);
}
for (int i = 0; i < n; i++) {
printf("arr[%d].id = %d , arr[%d].name = %s , arr[%d].age = %d\n",i,arr[i].id,i,arr[i].name,i,arr[i].age);
}
}
int main(int argc, char* argv[]) {
test();
return 0;
}打印效果如下：
11.6.结构体指针操作
顾名思义，结构体指针本质是指针，该指针指向结构体的地址，即数据类型是一个 结构体*：
写法类比：
c
//定义结构体：
struct struct_name{int id;};
//定义结构体变量：
struct struct_name a;
//定义结构体指针变量：
struct struct_name* p;
//结构体变量调用结构体元素：
a.id;
//结构体指针变量调用结构体元素：
a->id; //也可以写作(*a).id;图解如下：
示例一：结构体指针；
c
#include<stdio.h>
#include<string.h>
struct stu
{
int id;
char name[32];
int age;
};
void test() {
struct stu xiaochen = { 100,"晓晨",18 };
printf("id = %d,name = %s,age = %d\n", xiaochen.id, xiaochen.name, xiaochen.age);
struct stu* p = &xiaochen;
p->age = 20;
p->id = 101;
strcpy_s(p->name, 32, "安东尼");
printf("id = %d,name = %s,age = %d\n", xiaochen.id, xiaochen.name, xiaochen.age);
}
int main(int argc, char* argv[]) {
test();
return 0;
}打印效果如下：
案例二：从堆区为结构体申请一个空间；
c
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
struct stu
{
int id;
char name[32];
int age;
};
void test() {
struct stu* p = NULL;
int n = 0;
printf("请输入人数个数：");
scanf_s("%d", &n);
//从堆区申请结构体空间
p = (struct stu*)calloc(n, sizeof(struct stu));
if (p == NULL) {
perror("err");
return;
}
//获取键盘输入
for (int i = 0; i < n; i++) {
printf("请输入第%d个学生信息：", i + 1);
scanf_s("%d %s %d", &(p+i)->id, (p+i)->name,32, &(p+i)->age);
}
//遍历键盘输入
for (int i = 0; i < n; i++) {
printf("p.id = %d p.name = %s p.age = %d\n", (p+i)->id, (p+i)->name, (p+i)->age);
}
//释放空间
if (p != NULL) {
free(p);
p = NULL;
}
}
int main(int argc, char* argv[]) {
test();
return 0;
}打印效果如下：
示例三：从堆区为结构体数组申请一个空间，并且分函数实现（空间复杂度尽可能地小）；
c
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
struct stu
{
int id;
char name[32];
int age;
};
struct stu* get_mem(int n) {
return (struct stu*)calloc(n, sizeof(struct stu));
}
struct stu* set_data(struct stu* p, int* n) {
for (int i = 0; i < *n; i++) {
printf("请输入第%d个同学信息：", i + 1);
scanf_s("%d %s %d", &(p + i)->id, (p + i)->name, 32, &(p + i)->age);
}
return p;
}
void print_data(const struct stu* p, int* n) {
//const
for (int i = 0; i < *n; i++) {
printf("student%d.id = %d student%d.name = %s student%d.age = %d\n", i + 1, (p + i)->id, i + 1, (p + i)->name, i + 1, (p + i)->age);
}
return;
}
void test() {
printf("请输入学生的个数：\n");
int n;
scanf_s("%d", &n);
struct stu* arr = NULL;
//根据学生个数申请空间
arr = get_mem(n);
if (arr == NULL) {
perror("err");
return;
}
//为申请的空间赋值
arr = set_data(arr, &n);
//输出空间内容
print_data(arr, &n);
//释放空间
if (arr != NULL) {
free(arr);
arr = NULL;
}
}
int main(int argc, char* argv[]) {
test();
return 0;
}打印效果如下：
结构体指针作为函数的参数
**示例一：**定义一个函数，给结构体成员获取键盘输入；
c
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
struct stu
{
int id;
char name[32];
int age;
};
void method(struct stu* student) {
printf("请输入学生的信息（学号 名字 年龄）：");
scanf_s("%d %s %d", &student->id, student->name, 32, &student->age);
printf("xiaochen.id = %d xiaochen.name = %s xiaochen.age = %d\n", student->id, student->name, student->age);
}
void test() {
struct stu xiaochen;
method(&xiaochen);
}
int main(int argc, char* argv[]) {
test();
return 0;
}打印效果如下：
11.7.typedef取别名
使用步骤：
- 先用已有的类型定义一个相对应的变量
- 用别名替换变量名
- 在整个表达式前添加 typedef
注意：typedef 不能创造新的类型，只是给现有类型取别名；
给 int 类型取别名：
c
#include<stdio.h>
typedef int INT;
void test() {
INT num = 10;
printf("INT num = %d\n", num);
}
int main(int argc, char* argv[]) {
test();
return 0;
}打印效果如下：
给数组取别名：
c
#include<stdio.h>
typedef int INT[5];
void test() {
INT num = {1,2,3,4,5};
//此时 arr 就是一个拥有5个元素，每个元素为 int 型的数组，arr 是数组首地址
for (int i = 0; i < 5; i++) {
printf("%d ", *(num + i));
}
printf("\n");
}
int main(int argc, char* argv[]) {
test();
return 0;
}打印效果如下：
给指针取别名：
c
#include<stdio.h>
typedef int* INT;
void test() {
INT num = NULL;
int a = 10;
num = &a;
printf("*num = %d\n", *num);
}
int main(int argc, char* argv[]) {
test();
return 0;
}打印效果如下：
给函数指针取别名：
c
#include<stdio.h>
int sum(int a, int b) {
return a + b;
}
typedef int (*SUM)(int,int) ;
//SUM 是一个函数指针类型，该函数必须有两个 int 形参以及一个 int返回值
void test() {
SUM p = sum;
printf("*num = %d\n", p(100,200));
}
int main(int argc, char* argv[]) {
test();
return 0;
}打印效果如下：
给结构体类型取别名：
c
#include<stdio.h>
#include<string.h>
typedef struct stu
{
int id;
char name[32];
int age;
}STU; //此时的STU不是结构体变量，而是结构体类型
void test() {
STU xiaochen = { 0 };
xiaochen.age = 19;
xiaochen.id = 101;
strcpy_s(xiaochen.name, 32, "晓晨");
printf("%s %d %d\n", xiaochen.name, xiaochen.id, xiaochen.age);
}
int main(int argc, char* argv[]) {
test();
return 0;
}打印效果如下：
11.8.结构体内存对齐
引入实例：
c
#include<stdio.h>
struct data1
{
char ch1; //1B
char ch2; //1B
char ch3; //1B
short num; //2B
};
struct data2
{
char ch1; //1B
char ch2; //1B
char ch3; //1B
int num; //4B
};
struct data3
{
char ch1; //1B
char ch2; //1B
char ch3; //1B
double num; //8B
};
void test() {
struct data1 d1;
printf("sizeof(d1) = %d\n", sizeof(d1));
struct data2 d2;
printf("sizeof(d2) = %d\n", sizeof(d2));
struct data3 d3;
printf("sizeof(d3) = %d\n", sizeof(d3));
}
int main(int argc, char* argv[]) {
test();
return;
}打印效果如下：
从上面例子所打印结果我们可以得到一个观察结论：
结构体的大小由占内存最大的那个基本数据类型所决定，即结构体的单位内存大小就是内存最大的基本数据类型的内存大小，这就是结构体的内存向大对齐；
结构体内存分布
示例如下：
c
struct data{
char c; //1B
int i; //4B
};方法如下：
-
确定分配单位：每一行应该分配的字节数；
由结构体中最大的基本类型长度决定；
-
确定成员的起始位置的偏移量 == 成员的基本类型含零整数倍；
-
收尾工作：结构体总大小 == 分配单位的整数倍；
案例一：
c
typedef struct {
int a;
char b;
short c;
char d;
}DATA;画图如下：
证实如下：
c
#include<stdio.h>
typedef struct {
int a;
char b;
short c;
char d;
}DATA;
void test() {
DATA data = { 0,0,0,0 };
printf("%u\n", &data.a);
printf("%u\n", &data.b);
printf("%u\n", &data.c);
printf("%u\n", &data.d);
}
int main(int argc, char* argv[]) {
test();
return;
}打印效果如下：
案例二：
c
typedef struct {
char a;
short b;
short c;
int d;
char e;
}DATA;画图如下：
案例三：
c
typedef struct {
char a;
short b;
char c;
short d;
}DATA;画图如下：
结构体内存分布的作用
便于指针作用于结构体中；
示例如下：
一个结构体中有如下成员：
c
typedef struct {
char a;
int b;
short c;
}DATA;我们要通过指针去取到 short c ；
c
#include<stdio.h>
typedef struct {
char a;
int b;
short c;
}DATA;
void test() {
DATA data = { 'a',10,20 };
char* p = NULL;
p = &data.a;
p = p + 8;
printf("data.c = %d\n", *(short*)p);
}
int main(int argc, char* argv[]) {
test();
return;
}打印效果如下：
11.9.结构体嵌套结构体
图解如下：
示例如下：
c
#include<stdio.h>
typedef struct {
int a;
int b;
}DATA1;
typedef struct {
int c;
int d;
DATA1 e; //结构体变量c作为DATA2的成员，这就是结构体嵌套结构体
}DATA2;
void test() {
DATA2 data = {0,0,{0,0}};
printf("请输入四个数字：\n");
scanf_s("%d %d %d %d", &data.e.a, &data.e.b, &data.c, &data.d);
printf("你输入的四个数是：\n");
printf("data.e.a = %d\ndata.e.b = %d\ndata.c = %d\ndata.d = %d\n", data.e.a, data.e.b, data.c, data.d);
}
int main(int argc, char* argv[]) {
test();
return;
}打印效果如下：
嵌套结构内存分布
该内存分布与单层结构体的内存分布方式大同小异；
方法如下：
-
确定分配单位：每一行应该分配的字节数；
由所有结构体中最大的基本类型长度决定的；
-
确定成员的偏移量 == 自身类型的含零整数倍；
结构体成员偏移量 == 被嵌套的结构体中最大的基本类型含零整数倍；
结构体成员中的成员偏移量是相对于被嵌套的结构体而言的；
-
收尾工作：结构体的总大小 == 分配单位的整数倍；
结构体成员的总大小 == 被嵌套的结构体里面最大基本类型整数倍；
案例一：
c
typedef struct {
short d;
char e;
}DATA2;
typedef struct {
short a;
int b;
DATA2 c;
short f;
}DATA1;画图如下：
证实如下：
c
#include<stdio.h>
typedef struct {
short d;
char e;
}DATA2;
typedef struct {
short a;
int b;
DATA2 c;
short f;
}DATA1;
void test() {
DATA1 data = { 0,0,{0,0},0 };
printf("%u\n", &data.a);
printf("%u\n", &data.b);
printf("%u\n", &data.c.d);
printf("%u\n", &data.c.e);
printf("%u\n", &data.f);
}
int main(int argc, char* argv[]) {
test();
return;
}打印效果如下：
案例二：
c
typedef struct {
short d;
char e;
}DATA2;
typedef struct {
int a;
short b;
DATA2 c;
short f;
}DATA;画图如下：
11.10.强制类型对齐
为了控制C语言中数据类型对齐不统一的问题，C语言中自带了一条处理语言：
c
#pragma pack (value);
//value只能是2^n，常用的几个是1，2，4，8；这样声明就能够将该文件中的数据类型强制对齐于某一个值，但是要注意以下事项：
指定对齐方式（value）与数据类型对齐默认值相比取较小值；
**解释说明：**如果我们指定的是 4，但是系统默认对齐值是 2 ，那么我们所设置的对齐方式无效，系统会默认进行比较，并且选择较小的值，如果我们指定的是 2，但是系统默认对齐值是 4，那么我们所设置的对齐方式就会生效；
- 例一：指定值是 1，则 short、int、float 等均为 1；
- 例二：指定值是 2，则 char 仍然为 1，short 为 2，int 也为 2；
下面是具体步骤：
- 确定分配单位：每一行应该分配的字节数 ==> min(value,默认分配单位)；
- 成员偏移量 == 成员自身类型的含零整数倍；
- 收尾工作：总大小就是分配单位的整数倍；
那么我们可以通过强制类型对齐来计算一个结构体的真实大小，即不含有空地值的大小：
c
#include<stdio.h>
#pragma pack (1)
typedef struct {
char a; //1B
int b; //4B
short c; //2B
}DATA;
void test() {
DATA data = { 'a',10,20 };
printf("the real size of data is %d Bite\n", sizeof(data));
}
int main(int argc, char* argv[]) {
test();
return 0;
}打印效果如下：
无论是系统默认对齐，还是强制类型转换都有可能会改变一个结构体的内存大小，除此之外，调整结构体的成员顺序也有可能改变一个结构体的大小，但是这是一个时间复杂度与空间复杂度的相互牵制问题，如果想让空间复杂度小一点，那么就尽量把数据类型大小相同的或者相近的成员在编写代码阶段编在一起；