【C语言】结构体

❤️欢迎来到我的博客❤️

结构的基础知识

结构是一些值的集合，这些值称为成员变量，结构的每个成员可以是 不同类型的变量
结构的成员可以是标量、数组、指针，甚至是其他结构体
结构体可以用来描述复杂对象

结构的声明

struct tag
{
 member-list;//成员列表
}variable-list;//变量列表

特殊的声明

在声明结构的时候，可以不完全的声明。
比如：

//匿名结构体类型
struct 
{
	char name[20];
	int age;
}s1;//需要直接创建变量，因为结构体没有名字，所以之后不能再创建

struct
{
	int a;
	char c;
	double c;
}x;

struct
{
	int a;
	char c;
	double c;
}*p;

int main()
{
	//p = &x;错误
	//编译器会把上面的两个声明当成完全不同的两个类型。
	//所以是非法的。
	return 0;
}

结构的自引用

什么是结构的自引用呢？
我们在实现一些代码的时候，可能会有以下场景：

这样是否可行？

//节点
struct Node
{
	int data;//数据
	struct Node next;//下一个节点
};

并不行，因为这样写这个节点的大小就会变成无限大。

正确的自引用方式：

struct Node
{
	int data;
	struct Node* next;//下一个节点的地址
};

这时他的大小就是可控的了。

一个节点能包含同类型的下一个节点的地址，这就叫结构体的自引用。

结构体变量的定义和初始化

有了结构体类型，那如何定义变量，其实很简单。

struct Point
{
 int x;
 int y;
}p1 = {10，20}; //声明类型的同时定义变量p1并赋值
struct Point p2; //定义结构体变量p2

struct S
{
	int num;
	char ch;
	float d;
};

struct S S1 = { .ch = 'w',.num = 100,.d = 1.2f };//乱序初始化，需要指定结构体成员

//初始化：定义变量的同时赋初值。
struct Point p3 = {x, y};

struct Stu//类型声明
{
 char name[15];//名字
 int age;//年龄
};
struct Stu s = {"zhangsan", 20};//初始化

struct Node
{
 int data;
 struct Point p;
 struct Node* next; 
}n1 = {10, {4,5}, NULL}; //结构体嵌套初始化

struct Node n2 = {20, {5, 6}, NULL};//结构体嵌套初始化

结构体中也可以出现结构体

结构体内存对齐

我们已经掌握了结构体的基本使用了。
现在我们深入讨论一个问题：计算结构体的大小。

struct S1
{
	char c1;//1
	int i;//4
	char c2;//1
};

struct S2
{
	char c1;//1
	char c2;//1
	int i;//4
};

int main()
{
	//成员个数，成员类型一模一样，但是顺序不一样，那么他们的大小会一样吗？
	printf("%d\n", sizeof(struct S1));
	printf("%d\n", sizeof(struct S2));
	return 0;
}

运行效果：

发现我们只是调整了成员顺序，他们的大小就不一样了。
为什么只需要创建6个字节的空间，却创建了8，12的空间？

结构体的数据的存放，结构体的成员变量的空间的开辟，不能简单的按照他自身的大小来连续存放。
那么结构体对齐规则是怎么样的？

1.结构体的第一个成员，对齐到结构体在内存中存放位置的0偏移处。
2.从第二个成员开始，每个成员都要对齐到（一个对齐数）的整数倍处。
对齐数：结构体自身大小和默认对齐数的较小值
VS默认对齐数是：8
Linux gcc：没有默认对齐数，对齐数就是结构体成员自身大小
3.结构体总大小，必须是所有成员的对齐数中最大对齐数的整数倍
4.如果结构体中嵌套了结构体成员，要将嵌套的结构体成员对齐到自己的成员中最大对齐数的整数倍数。

我们可以使用offsetof来验证我们计算的偏移量是否正确。

#include <stdio.h>
#include <stddef.h>

struct S1
{
	char c1;
	int i;
	char c2;
};

int main()
{
	printf("%d\n", offsetof(struct S1, c1));//计算c1的偏移量
	printf("%d\n", offsetof(struct S1, i));//计算i的偏移量
	printf("%d\n", offsetof(struct S1, c2));//计算c2的偏移量
	return 0;
}

运行效果：

可以看到，偏移量和我们计算的一模一样。

那我们来看第二个结构体的大小为什么为8字节：

我们再来看一个例子：

那么如果结构体中嵌套了一个结构体，这又该如何计算他的大小呢？

结构体的总大小必须是最大对齐数的整数倍，这里的最大对齐数是:包含嵌套结构体成员中的对齐数，的所有对齐数中的最大值。

为什么存在内存对齐?

大部分的参考资料都是如是说的：

1. 平台原因(移植原因)：
   不是所有的硬件平台都能访问任意地址上的任意数据的；某些硬件平台只能在某些地址处取某些特定类型的数据，否则抛出硬件异常。
2. 性能原因：
   数据结构(尤其是栈)应该尽可能地在自然边界上对齐。
   原因在于，为了访问未对齐的内存，处理器需要作两次内存访问；而对齐的内存访问仅需要一次访问。

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

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

让占用空间小的成员尽量集中在一起。

修改默认对齐数

之前提到VS环境下默认对齐数为8，那我们能不能修改这个对齐数呢？

#pragma可以改变我们的默认对齐数。

#pragma pack()//设置默认对齐数

#pragma pack(1)//设置默认对齐数为1
struct S1
{
	char c1;
	int i;
	char c2;
};
#pragma pack()//取消设置的默认对齐数，还原为默认

int main()
{
	printf("%d\n", sizeof(struct S1));
	return 0;
}

运行效果：

可以看到，结构体的大小确实变小了，那么这个6是怎么得到的呢？

结构在对齐方式不合适的时候，我么可以自己更改默认对齐数。

结构体成员的访问和结构体传参

结构体变量访问成员
结构变量的成员是通过点操作符（.）访问的。点操作符接受两个操作数。

也可以通过结构体指针访问指向变量的成员
有时候我们得到的不是一个结构体变量，而是指向一个结构体的指针。

如下：

struct S
{
	int a;
	char d;
};

struct P
{
	double c;
	struct S s;
	float f;
};

void Print1(struct P sp)
{
	//结构体变量.成员
	printf("%lf %d %c %f\n", sp.c, sp.s.a, sp.s.d, sp.f);
}

void Print2(struct P* p1)
{
	//结构体指针->成员
	printf("%lf %d %c %f\n", p1->c, p1->s.a, p1->s.d, p1->f);
	 //使用结构体指针访问指向对象的成员
}

int main()
{
	struct P p = { 5.5,{100,'b'},3.14f };
	//结构体传参
	Print1(p);//传值调用
	Print2(&p);//传址调用

	return 0;
}

上面的 print1 和 print2 函数哪个好些？
答案是：首选print2函数。
原因：

函数传参的时候，参数是需要压栈的。
如果传递一个结构体对象的时候，结构体过大，参数压栈的的系统开销比较大，所以会导致性能的下降。
结论：
结构体传参的时候，要传结构体的地址。

结构体传参

直接上代码：

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;
}

首选传地址
原因：

函数传参的时候，参数是需要压栈，会有时间和空间上的系统开销。
如果传递一个结构体对象的时候，结构体过大，参数压栈的的系统开销比较大，所以会导致性能的下降。
结构体传参的时候，要传结构体的地址。

---

以上就是本篇的全部内容了，希望大家看完能有所收获

❤️ 创作不易，点个赞吧~❤️