C/C++中通过结构体/类中的某个成员变量的内存地址，获取其在结构体/类中的偏移量

引言

这段时间因为工作需要在研究开源工具Xdelta3的源码 ，发现了其中一个很有趣但不算常见的操作，先贴一下源码：

static inline xd3_rinst *xd3_rlist_entry(xd3_rlist *l) 
{ 
    return (xd3_rinst *)((char *)l - (ptrdiff_t) & ((xd3_rinst *)0)->link); 
}

补充一下上面语句中出现的几个类型定义：

typedef unsigned char      	uint8_t;
typedef unsigned int 		usize_t;
typedef unsigned long long 	xoff_t;
typedef struct _xd3_rlist 	xd3_rlist;
typedef struct _xd3_rinst  	xd3_rinst;

struct _xd3_rlist
{
  xd3_rlist  *next;
  xd3_rlist  *prev;
};

struct _xd3_rinst
{
  uint8_t     type;
  uint8_t     xtra;
  uint8_t     code1;
  uint8_t     code2;
  usize_t     pos;
  usize_t     size;
  xoff_t      addr;
  xd3_rlist   link;
};

我先说明一下函数xd3_rinst *xd3_rlist_entry(xd3_rlist *l)的作用，就是返回参数l所属的xd3_rinst类型结点的内存地址，其中包含type xtra ...等成员变量。

获取结构体中的某个变量的偏移量

我们知道，结构体类型中的成员变量是存储在内存中一段连续的内存地址上，我们所实例化的对象其实指向的是这段连续内存的首地址，也是结构体中第一个成员变量的内存地址，其他成员变量的取值都采用相对位置取址，也就是我们常说的偏移量取址，这和数组的取值是一个道理。

举个栗子

我们定义一个结构体

struct MyStruct
{
	char a;
	MyStruct* next;
};

这个结构体中包含两个成员变量，一个字符型变量和一个指针类型变量。
一个字符型变量占1个字节单位长度，一个指针类型变量在32位系统中占4个字节单位长度。但我们要考虑到字节对齐，在C/C++中，默认以结构体中最长的类型变量所占的字节数来对齐，在该结构体中最长的数据类型是指针类型占4个字节，因此该结构体以4字节对齐。如下图所示：

因此在32位系统中，这个结构体的长度为8个字节sizeof(MyStruct) = 8；由此我们就可以知道变量next的偏移量为4。
那么，假如我们并不知道结构体内部定义了哪些变量，想获取某个成员变量的偏移量应该怎么办呢？首先我们可以通过如下操作来获取某个成员变量的内存地址：

MyStruct  obj;
MyStruct* point = &obj;
int addr = (int)&point->next;
printf("addr = 0x%x\n", addr);

得到的结果为：

由于我们获取的是一个实例化对象的成员变量的地址，对象在每次实例化时分配的内存地址都是不确定的，因此获得的成员变量地址addr也是不确定的：


上面的操作应该很容易理解吧，point是指向实例化对象obj内存地址的指针，通过偏移寻址来获取成员变量next的内存地址。诶？偏移寻址？我们想求偏移量是不是就可以通过计算偏移寻址的值来获取偏移量呢？将我们获取的成员变量的地址减去对象的起始地址不就能得到该成员变量的偏移量了吗？

MyStruct  obj;
MyStruct* point = &obj;
int start_addr = (int)&obj;			//起始地址
int off_addr = (int)&point->next;	//偏移地址
int offset = off_addr - start_addr;	//偏移量
printf("起始地址start_addr = 0x%x\n", start_addr);
printf("偏移地址off_addr = 0x%x\n", off_addr);
printf("偏移量offset = %d\n", offset);

这样做确实可以求出成员变量的偏移量：

但这样操作属实麻烦了点，有没有什么更方便的操作呢？当然有！既然内存地址不固定不便于计算，那么我们固定一个地址不就好了吗。

int addr = (int)&((MyStruct*)100)->next;
printf("成员变量next的地址addr = %d\n", addr);

这里的数字100表示从地址100开始计算结构体MyStruct的成员变量的偏移地址，得到的结果如下：

我们知道成员变量next的偏移量为4，所以其偏移地址 = 起始地址(100) + 偏移量(4) = 104；那如果我们将起始地址固定在0，那得出的偏移地址不就是偏移量了吗？

int offset = (int)&((MyStruct*)0)->next;
printf("成员变量next的偏移量offset = %d\n", offset);

得到成员变量next的偏移量：

大功告成！这样是不是要比通过地址相减来求偏移量方便很多:)

这个方法也同样适用于求类中成员变量的偏移量

class MyClass
{
public:
	char a;
	double b;
	int c;
};

int main() 
{
	int offset = (int)&((MyClass*)0)->c;
	printf("成员变量c的偏移量offset = %d\n", offset);
	return 0;
}

根据字节对齐的规则，MyClass类以8字节(double)对齐，a占1个字节，填充7个字节，b占8个字节，因此c的偏移量为16。

xd3_rlist_entry()函数的解析

通过上面的分析之后，我们再看表达式 (ptrdiff_t) &((xd3_rinst *)0)->link 就能很容易的知道，该表达式获取的是结构体xd3_rinst中成员变量link的偏移量。

#include <stdio.h>

typedef unsigned char uint8_t;
typedef unsigned int  usize_t;
typedef unsigned long long xoff_t;
typedef struct _xd3_rinst xd3_rinst;
typedef struct _xd3_rlist xd3_rlist;

struct _xd3_rlist
{
	xd3_rlist* next;
	xd3_rlist* prev;
};

struct _xd3_rinst
{
	uint8_t		type;
	uint8_t		xtra;
	uint8_t		code1;
	uint8_t		code2;
	usize_t		pos;
	usize_t		size;
	xoff_t		addr;
	xd3_rlist	link;
};

int main()
{
	int offset = (ptrdiff_t) & ((xd3_rinst*)0)->link;
	printf("成员变量link的偏移量offset = %d\n", offset);
	return 0;
}

结构体xd3_rinst以8字节(xd3_rlist)对齐，type占1个字节，xtra占1个字节，code1占1个字节，code2占1个字节，pos占4个字节，size占4个字节，填充4个字节，addr占8个字节，所以link的偏移量 = (1 + 1 + 1 + 1 + 4) + (4 + 4) + (8) = 24。

看回源码：

static inline xd3_rinst *xd3_rlist_entry(xd3_rlist *l) 
{ 
    return (xd3_rinst *)((char *)l - (ptrdiff_t) & ((xd3_rinst *)0)->link); 
}

在C/C++中，对指针进行加减操作其实就是进行移位操作，之所以要将l的类型强转为char*，是因为char*每次移动的尺度是1个字节，我们求出的偏移量是以字节为单位的，我们将指针l减去xd3_rinst::link的偏移量，其实就等同于将指针前移24个字节，如果不做强制类型转换，那么减去24就相当于前移24个xd3_rlist类型的单位长度(24 * 8 = 192字节)。
将l的内存地址减去其对应偏移量，其实就是我们前面用相对地址求偏移量的逆过程，将偏移地址减去其偏移量得到的就是起始地址。在本例中，起始地址对应的就是xd3_rinst::type的内存地址，也就是结构体xd3_rinst所在连续内存的开始地址。
在实际调用函数xd3_rlist_entry(xd3_rlist *l)时，传入的实参l是有确定的内存地址的，因此函数返回的就是l所属的xd3_rinst结构体类型实例化对象的内存地址。

欢迎批评指正！