Automatically obtain the position offset of member variables inside the structure

Ask a question ： The name of a structure and the name of a member variable in the structure are known , How to get the position offset of the member variable in the structure ？

Take up a C Examples of language structures ：

typedef struct _node {
    
    int value32;
    long value64;
    struct _node * next;
} Node;

As shown above , How to know next stay Node Position offset in ？
Such a simple structure can be calculated manually . But if it is a relatively large structure , There are tens or hundreds of member variables , To know the relative position shift of a variable in the middle , It's a little bit more complicated .
Even if you can count , Some other member variables may be added before it in the future , When the time comes , The calculated value is invalid , Count again .
therefore , If you use a program to calculate the offset of a specified member variable , What should be done ？
You can do this with the following line of code .

#define GET_OFFSET(_type, _member) ((unsigned long)(&((_type *)0)->_member))

Explain it. ：
Address 0 As a Node Instance address , So that nature can use ->next get next Member variables , Then we can get the address character next The address of the member variable .
Because the address of the instance itself is from 0 Start , So here we get next The address of the member variable is naturally offset .
So why is this value not negative ？
I guess , This is because the compiler assumes that the instance is in the heap , In the process space of the program , The heap address increases from the low address to the high address , So it's a positive number . Or maybe it's not that complicated at all , The compiler simply thinks that the address of the member variable is gradually increasing relative to the starting address of the instance , Not gradually decreasing .

The complete program code is as follows ：

#include <stdio.h>

#define GET_OFFSET(_type, _member) ((unsigned long)(&((_type *)0)->_member))

typedef struct _node {
    
    int value32;
    long value64;
    struct _node * next;
} Node;


int main()
{
    
    unsigned long offset = GET_OFFSET(Node, next);
    
    printf("offset of next = %ld\n", offset);
    
    return 0;
}

The execution result of the above procedure is ：

offset of next = 16

This method is right for C++ Class of also applies , But only for public Type to calculate the position offset , as follows ：

#include <iostream>
using namespace std;

#ifdef __cplusplus
#define ENV "CPP"
#else
#define ENV "C"
#endif

#define GET_OFFSET(_type, _member) ((unsigned long)(&((_type *)0)->_member))

class Node {
    
public:
    virtual int getValue32() {
     return value32; }
    virtual int getValue64() {
     return value64; }
    Node(int v32=0, int v64=0) : value32(v32), value64(v64) {
    }

private:
    int value32;
    long value64;

public:
    Node * next;
};


int main()
{
    
    unsigned long offset = GET_OFFSET(Node, next);
    unsigned long offset_in_c_way = (unsigned long)(&((Node *)0)->next);
    
    cout << "ENV=" << ENV <<endl;
    
    cout << "offset of next = " << offset << endl;

    return 0;
}

The execution result is ：

ENV=CPP
offset of next = 24

there offset The reason why it has become 24 instead of 16, Because in Node There is a virtual table pointer at the top of the instance , Occupied 8 Bytes , therefore next The position of the member variable is offset from 16 Bytes become 24 byte .

Another question is coming , What is the use of calculating the offset of member variables within a structure ？
See the next section for details .

（ End ）