【C语言】结构体与offsetof实现

远看山有色,近听水无声。春去花还在,人来鸟不惊。 --- 唐代·王维《画》


这篇博客我们会详细介绍结构体相关知识,干货满满。

结构体的声明🍀

一般来说结构体应该有成员列表和变量列表这两个基础的模式。

例如描述一个学生:

c 复制代码
struct strudent
{

	char name[20];//名字
	int age;//年龄
	char sex[5];//性别
	char id[20];//学号
}; //分号不能丢

当然也不是只有这一种声明。

特殊的声明🐽

在声明结构的时候,可以不完全的声明。

比如:

c 复制代码
//匿名结构体类型
struct
{
	int a;
	char b;
	float c;
}x;
struct
{
	int a;
	char b;
	float c;
}a[20], * p;

这就是匿名结构体

但是如果是这样那么这两个结构体是一样的吗?

c 复制代码
//在上面代码的基础上,下面的代码合法吗?
p = &x;

其实是不行的;

警告:
编译器会把上面的两个声明当成完全不同的两个类型。
所以是非法的。

结构体的自引用✳️

在结构中包含一个类型为该结构本身的成员是否可以呢?

c 复制代码
struct Node
{
 int data;
 struct Node next;
};
//可行否?
//如果可以,那sizeof(struct Node)是多少?

当然是不可以,struct Node next永远都还有下一个struct Node next,这样怎么可以呢?

正确的自引用方式:

//代码2

c 复制代码
struct Node
{
 int data;
 struct Node* next;
};

注意:

c 复制代码
typedef struct
{
 int data;
 Node* next;
}Node;
//这样写代码,可行否?

不行 首先这个匿名结构体,重定义为Node,但是重定义之前,就定义了Node*next,

这个不被允许的!

解决方案:

c 复制代码
typedef struct Node
{
 int data;
 struct Node* next;
}Node;

还有数据结构中常见的写法

c 复制代码
typedef struct Node
{
	int data;//数据
	struct Node* next;//指针
} Node, * pNode;

//pNode --> struct Node*

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

定义和初始化:

c 复制代码
struct P
{
	int a;
	int b;
}p;
struct P p1;//定义结构体变量p2
struct P p2 = { 1,2 };//初始化:定义变量的同时赋初值。
struct Stu        //类型声明
{
	char name[15];//名字
	int age;      //年龄
};
struct Stu s = { "zhangsan", 20 };//初始化
c 复制代码
struct P
{
	int a;
	int b;
}p;//声明类型的同时定义变量p

还有结构体嵌套的情况。

c 复制代码
struct book
{
	char name[20];
	int num;
	char id[20];
}b1 = {"C语言",20,"1234"};
struct Node
{
	struct book b;
	struct Node* next; //结构体嵌套
};
int main()
{
	printf("%s %d %s\n", b1.name, b1.num, b1.id);
	struct Node n = { {"Java", 20, "321"}, NULL };//结构体嵌套初始化
	return  0;
}

结构体内存对齐

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

这也是一个特别热门的考点: 结构体内存对齐

我们来看这两个结构体

c 复制代码
struct S1
{
	char c1;
	int i;
	char c2;
};
struct S2
{
	char c1;
	char c2;
	int i;
};

int main()
{
	printf("%d\n", sizeof(struct S1));//12
	printf("%d\n", sizeof(struct S2));//8

	return 0;

为什么大小不一样呢?

这就要讲到结构体内存对齐
首先得掌握结构体的对齐规则

  1. 第一个成员在与结构体变量偏移量为0的地址处。
  2. 其他成员变量要对齐到某个数字(对齐数)的整数倍的地址处。
    对齐数 = 编译器默认的一个对齐数 与 该成员大小的较小值。

    VS中默认的值为8
  3. 结构体总大小为最大对齐数(每个成员变量都有一个对齐数)的整数倍。
  4. 如果嵌套了结构体的情况,嵌套的结构体对齐到自己的最大对齐数的整数倍处,结构体的整体大小就是所有最大对齐数(含嵌套结构体的对齐数)的整数倍

我们来看

这样一来S2也就很好解释了,

c 复制代码
struct S2
{
	char c1;
	char c2;
	int i;
};

c1 0

c2 1

i 4-7

总大小刚好是8。

c 复制代码
一般的我们已经知道了,现在来看看嵌套的
struct S3
{
 double d;
 char c;
 int i;
};
printf("%d\n", sizeof(struct S3));
struct S4
{
	char c1;
	struct S3 s3;
	double d;
};
printf("%d\n", sizeof(struct S4));

struct S3的大小是16

那么S4的大小是多少呢?

首先看到最后一个原则,也就是S3在S4内对齐时大小为8,是最大对齐数。

一共就是32。

补充一句VS和Linus的

为什么存在内存对齐?

大部分的参考资料都这样说的:

1.平台原因(移植原因):

不是所有的硬件平台都能访问任意地址上的任意数据的;某些硬件平台只能在某些地址处取某些特 定类型的数据,否则抛出硬件异常 。(比如只能访问4的倍数的地址上的数据)

抛出硬件异常是指在计算机系统中,发生了与硬件相关的错误或异常情况。这些异常可能由于硬件故障、硬件错误、硬件不兼容性或硬件操作不当等原因引起。

2. 性能原因:

数据结构(尤其是栈)应该尽可能地在自然边界上对齐。

原因在于,为了访问未对齐的内存,处理器需要作两次内存访问;而对齐的内存访问仅需要一次访问。(32位下一次访问4个byte)

不考虑对齐要读取两次才能读完i的4个字节的内容(32位).

而考虑的话,i只需要读取一次就能读完,

这里实际上就提高了效率,牺牲空间来提升效率。

要读取一次就能读完,

这里实际上就提高了效率,牺牲空间来提升效率。
总体来说: 结构体的内存对齐是拿空间来换取时间的做法。

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

其实很简单:

c 复制代码
//例如:
struct S1
{
 char c1;
 int i;
 char c2;
};
struct S2
{
 char c1;
 char c2;
 int i;
};

都是同样的结构体成员,但是把小的放在一起就节省空间 (这是上面讲过的)。

修改默认对齐数🐣

c 复制代码
struct S
{
	char c;//1
	double d;//8
};

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

还是这样这个代码

大小为16。

但是呢,我们可以用用#pragma pack() 来修改默认对齐数

c 复制代码
#pragma pack(4)
struct S
{
	char c;//1
	double d;//8
};
#pragma pack()//取消设置的默认对齐数,还原为默认

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

我们将默认对齐数修改到4时,大小就已经变化了,

为什么呢?char c; 0

double d; 4:8 = 4, 4-11。 一共就是12。

也可以设置不内存对齐,紧挨着排#pragma pack(1)

c 复制代码
#pragma pack(1)
struct S
{
	char c;//1
	double d;//8
};
#pragma pack()//取消设置的默认对齐数,还原为默认
int main()
{
	struct S s;
	printf("%d\n", sizeof(s));
	return 0;
}

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

虽然我们能够随便改变,但是我们要改最好还是让默认对齐数是2的幂,也是为了让我们的硬件有一个好的发挥

offsetof及其实现💥

其实offsetof是用宏来实现的,与一般的函数不同。


这个宏是用来查看结构体成员的偏移量的,并返回偏移量值。

我们知道结构体的首元素需要放在0偏移处。之后的成员要放在正确的偏移处。

c 复制代码
struct S3
{
	double d;
	char c;
	int i;
};

int main()
{
	printf("%d\n", sizeof(struct S3));
	printf("%u\n", offsetof(struct S3, d));
	printf("%u\n", offsetof(struct S3, c));
	printf("%u\n", offsetof(struct S3, i));

	return 0;

}

来看看这个

我们可以算一算确实是这样,

double d; 0 - 7

char c; 8

int i; 12-15

一共16。

每个变量最开始的地方就是这个变量相对于0的偏移量。

那么既然这是一个宏那该如何去实现呢?

我们需要借助这幅图好好理解一下,到底偏移量意味着什么。

我们看到实际上偏移量就是该变量的地址的值减去首地址。

假设0偏移处地址是0x0012ff40。

0x0012ff48-0x0012ff40=8。

0x12ff4c-0x0012ff40 = 12。

这样我们对偏移量就有了不一样的理解。

那么我们如何来实现呢?

c 复制代码
#include<stddef.h>
#define OFFSETOF(struct_type,member)  (int)&(((struct_type *)0)->member)

struct S3
{
	double d;
	char c;
	int i;
};

int main()
{	printf("%u\n", offsetof(struct S3, d));
	printf("%u\n", offsetof(struct S3, c));
	printf("%u\n", offsetof(struct S3, i));

	printf("%u\n", OFFSETOF(struct S3, d));
	printf("%u\n", OFFSETOF(struct S3, c));
	printf("%u\n", OFFSETOF(struct S3, i));

	return 0;

}

我们就是用这一行代码来实现的。
(int)&(((struct_type *)0)->member)

  1. (struct_type
    *)0:将0强制转换为指向struct_type类型的指针。这里假设结构体的实例位于0地址处,实际上并不是真的将结构体放在0地址处,而是为了方便计算偏移量而做的假设。
  2. ((struct_type*)0)->member:通过上述转换得到的指针,访问结构体中的成员member。这里并不会真的访问到实际的结构体,而是为了计算成员的偏移量而进行的操作。
    3. (int)&(((struct_type*)0)->member):通过取地址操作&,将上述成员的假设地址转换为实际的地址,并将其强制转换为int类型。这样就得到了成员的偏移量。

总结😈

这篇博客是用来梳理结构体知识的,并不算太难,算的上是对知识的检查和回顾,结构体对数据结构的学习十分重要希望大家都能学会 完(๑′ᴗ‵๑)

相关推荐
鸭鸭梨吖3 分钟前
产品经理笔记
笔记·产品经理
齐 飞29 分钟前
MongoDB笔记01-概念与安装
前端·数据库·笔记·后端·mongodb
lulu_gh_yu43 分钟前
数据结构之排序补充
c语言·开发语言·数据结构·c++·学习·算法·排序算法
丫头,冲鸭!!!1 小时前
B树(B-Tree)和B+树(B+ Tree)
笔记·算法
听忆.1 小时前
手机屏幕上进行OCR识别方案
笔记
Selina K2 小时前
shell脚本知识点记录
笔记·shell
2 小时前
开源竞争-数据驱动成长-11/05-大专生的思考
人工智能·笔记·学习·算法·机器学习
~yY…s<#>2 小时前
【刷题17】最小栈、栈的压入弹出、逆波兰表达式
c语言·数据结构·c++·算法·leetcode
霍格沃兹测试开发学社测试人社区3 小时前
软件测试学习笔记丨Flask操作数据库-数据库和表的管理
软件测试·笔记·测试开发·学习·flask
幸运超级加倍~3 小时前
软件设计师-上午题-16 算法(4-5分)
笔记·算法