CONTAINING_RECORD宏原理与使用详解

先不急着说CONTAINING_RECORD宏，我们从最浅显的代码开始讲解。

一、0指针的妙用

0指针，即nullptr、NULL，空指针，是不是很常见，一遇到它往往就是segment fault。代码，如下：

struct Test
{
    int a;
    float b;
};

Test* pTest = nullptr;
int a_value = pTest->a; // segment fault
int b_value = pTest->b; // segment fault
pTest->a = 1;           // segment fault
pTest->b = 1.0;         // segment fault

上述想必没有疑问吧。空指针难道就没有用了？不，下面看一个巧妙的应用。

typedef unsigned long long quint64;
Test* pTest = nullptr;
quint64 offset_a = (quint64)(&(pTest->a));  // offset_a==0
quint64 offset_b = (quint64)(&(pTest->b));  // offset_b==4

offset_a为0，offset_b为4，如果你觉得很惊喜，请继续看。

之所以pTest->a，pTest->b没有报错，是因为前面添加了取地址符&，相当于我们告诉编译器，并不是真的要取a、b的值，我们只是取a、b的地址，然鹅Test对象的地址pTest为0，根据C++对象内存布局，如下图，可知当Test对象地址为0时，实际上取到的a、b地址，也就是a、b变量相对于整个对象首地址的偏移量。

小结：

利用某结构的空指针，对该结构成员取地址，可以得到该成员的偏移量。

换言之，我们很容易利用成员地址反推出整个对象的地址。

二、CONTAINING_RECORD宏

CONTAINING_RECORD宏定义位于winnt.h中，如下：

//
// Calculate the address of the base of the structure given its type, and an
// address of a field within the structure.
//

#define CONTAINING_RECORD(address, type, field) ((type *)( \
                                                  (PCHAR)(address) - \
                                                  (ULONG_PTR)(&((type *)0)->field)))

该宏的功能，是根据某个结构体中成员变量的地址，计算出结构体地址。

• address，成员变量地址
• type，结构体类型
• field，成员变量名

该宏定义的原理，就是上一章中介绍的使用0指针获取成员偏移，然后再使用成员变量地址-成员偏移，就得到了结构体地址。

该宏定义的使用，如下：

struct School
{
    int level;
    float cost;
};

struct Student
{
    int age;
    School school;
};

School sch;
sch.level = 1;
sch.cost = 5000;

Student zhangsan;
zhangsan.age = 10;
zhangsan.school = sch;

Student* pStu = CONTAINING_RECORD(&zhangsan.school, Student, school);
qDebug() << &zhangsan;
qDebug() << pStu;

运行结果：

pStu与&zhangsan值相等。

貌似看起来，好像这么操作一遍，没什么用处。但是实际上，在某些情况下，还是非常有用的一个宏。

三、使用C++封装使用CONTAINING_RECORD宏

代码如下：

#include <QCoreApplication>
#include <QDebug>

//
// Calculate the address of the base of the structure given its type, and an
// address of a field within the structure.
//

#define CONTAINING_RECORD(address, type, field) ((type *)( \
                                                 (qint8*)(address) - \
                                                 (quint64)(&((type *)0)->field)))
// 轮子
class Wheel
{
public:
    Wheel(int count, int color)
        : count(count),
          color(color)
    {}

private:
    int count; // 数量
    int color; // 颜色
};

// 汽车
class Car
{
public:
    Car(int seat, Wheel wheel)
        : seat(seat),
          wheel(wheel)
    {}

    Wheel* getWheel()
    {
        return &wheel;
    }

    // 将轮子转换为对应的汽车
    static Car *wheelToCar(Wheel *pWheel)
    {
        return CONTAINING_RECORD(pWheel, Car, wheel);
    }

private:
    int seat; // 座位数量
    Wheel wheel; // 轮子
};

int main(int argc, char *argv[])
{
    QCoreApplication a(argc, argv);

    Wheel wheel(4, 1); // 4个轮子，1种颜色
    Car myCar(5, wheel); // 5个座位，1套轮子

    Car* pCar = Car::wheelToCar(myCar.getWheel());
    qDebug() << &myCar;
    qDebug() << pCar;

    return a.exec();
}

运行结果：

用途：

当我们需要将一个class中，某个成员对象(struct或class)，取出来，传递给其他api，其他api将这个成员对象作为参数进行一些处理，处理完后，还会将该对象传递回给我们，这时候，我们希望能够通过此对象获取到所在的整个对象，那么我们使用这个C++封装的宏，实现起来会很方便。

例如：

win下的IOCP异步IO中，会把OVERLAPPED结构传给api，处理完，会传回OVERLAPPED结构体。

以及linux下libaio异步IO中，也会iocb结构传给api，处理完，会传回iocb结构体。

---

若对你有帮助，欢迎点赞、收藏、评论，你的支持就是我的最大动力！！！

同时，阿超为大家准备了丰富的学习资料，欢迎关注公众号“超哥学编程”，即可领取。

本文涉及工程代码，公众号回复：19ContainingRecord，即可下载。