C语言-结构体

----------------------------

------------------

岁月漫长心怀热爱，携手共赴星辰大海

--------今天来到我们自定义类型

-----结构体的讲解

目录

结构体的类型声明和初始化

结构体的类型声明

结构体成员的直接访问

结构体成员的间接访问

嵌套结构体进行访问

使用typedef来定义结构体

匿名结构体类型

结构体的自引用

qsort排序结构体

结构体的传参

结构体内存对齐

为什么存在内存对齐?

#pragma改变编译器的默认对齐数

结构体实现位段

结构体位段的声明

位段的内存分配

位段的跨平台性

位段的运用

位段使用的注意事项

结构体的类型声明和初始化

结构体的类型声明

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字节内存块中。

结构体的内存对齐是拿空间来换取时间的做法

那在设计结构体的时候，我们既要满足对齐，又要节省空间，如何做到：

让占⽤空间⼩的成员尽量集中在⼀起

就像我们刚刚写的代码，S2的大小是8，S1的大小是12

#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个字节就可以了，节省了内存空间

位段的内存分配

1. 位段的成员可以是 int unsigned int signed int 或者是 char 等类型

2. 位段的空间上是按照需要以 4个字节（ int ）或者1个字节（ char ）的方式来开辟的。

3. 位段涉及很多不确定因素，位段是不跨平台的，注重可移植的程序应该避免使用位段。

所以位段很依赖编译器，我们来认识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;
}