C++程序员应了解的那些事（64）~ 指向 Data Member 的指针 ＜成员指针＞

【PART - 1】

         指向 data member 的指针是一个颇有用处的语言特性， 特别是如果你需要详细调查 class members 的底层布局的话。这个调查可以帮助你决定 vptr 是放在尾端还是起始处。 另一个用途是可以用来决定 clas 中 access sections 的次序。
        以下示例代码， 其中有一个 virtual function， 一个 static data member， 以及三个坐标值：

class Point3d
{
public:
    virtual ~Point3d();
    //...
protected:
    static Point3d origin;
    float _x, _y, _z;
};

        每一个 Point3d class object 含有三个坐标值， 以及一个 vptr， 至于 static data member origin， 将被放在 class object 之外， 唯一可能因编译器不同而不同的是 vptr 的位置。C++ standard 允许 vptr 被放在对象中的任何位置， 但是实际上， 所有编译器不是把 vptr 放在头部就是把它放在尾部。
         那么取某个坐标成员的地址， 代表什么意思？ 例如， 以下操作所得到的值代表什么：

&Point3d::_z;

        上述操作将得到 _z 坐标在 class object 中的偏移量, 最低限度其值将是 _x 和 _y 大小总和， 因为 C++ 语言要求同一个 access level 中的 members 的排列次序应该和声明次序相同。
       然而 vptr 的位置就没有限制， 再次重复， 实际上 vptr 不是放在对象的头部， 就是放在对象的尾部。 在一部 32位的机器上，每一 float 是 4 bytes， 所以我们应该期望刚才获得的值要不就是 8， 要不就是 12。但这比期望还是少 1， 也就是实际应该是 1， 5， 9 或 5， 9， 13等等， 为啥 Bjarne 要这么做呢？

       问题在于， 如何区分一个没有指向任何 data member 的指针和一个指向第一个 data member 的指针？观察以下代码：

float Point3d::*p1 = 0;
float Point3d::*p2 = &Point3d::_x;

        问题来了，如何区分 p1 与 p2？ 为了区分 p1 与 p2， 每一个真正的 member offset 的值都被加上 1， 因此不论编译器或使用这都必须记住， 在真正使用该值以指出一个 member 之前， 请先减掉 1。
       另外， 理解 指向 data member 的指针后， 我们发现要解释：

&Point3d::_z;
&origin._z;

之间的差异就非常明确了， ※取一个 nonstatic data member 的地址 将会得到它在 class 中的 offset， 而取一个绑定于 class object 身上的 data member 的地址将会得到该 member 在内存中的真正地址。把 &origin.z 所得结果减去 _z 的偏移值，并加 1， 就会得到 origin 的起始地址。                       上一行的返回值的类型应该是 float* 而不是 float Point3d::*。 由于上述操作所参考的是一个特定实例， 所以取一个 static data member 的地址， 意义也相同。

【PART - 2】

        在多重继承之下，若要将第二个(或后继) base class 的指针和一个与 derived 绑定的 member 结合起来， 那么将会因为需要加入 offset 值而变得复杂， 例如：

struct Base1{int val1;}
struct Base2{int val2;}
struct Derived:Base1, Base2{...};

void Func1(int Derived::*dmp, Derived *pd)
{
    //期望第一个应是 指向 derived class 的 member 的指针    
    //但假如传进的是一个指向 base class 的 member 的指针， 会怎样呢？
    pd->*dmp;
}
void Func2(Derived *pd)
{
    //bmp 将成为 1
    int Base2::*bmp = &Base2::val2;
    //bmp == 1
    //但是在 Derived 中， val2 == 5
    Func1(bmp, pd);
}

        当 bmp 被作为 Func1() 的第一个参数时， 它的值就必须因介入的 Base1 class 的大小调整， 否则 Func1 中这样的操作：pd->*dmp;将存取到 Base1::val1, 而非程序员所以为的 Base2::val2。要解决这个问题， 必须：编译器进行的内部转换

//编译器进行的内部转换
Func1(bmp + sizeof(Base1), pd);
//防范措施
Func1(bmp ? bmp + sizeof(Base1) : 0, pd);

        在VS Code中写了几行代码来打印上述各个 member 的 offset 值：执行的结果都是 1.

std::cout << &Base1::val1   << "\n";
std::cout << &Base2::val2   << "\n";
std::cout << &Derived::val1 << "\n";
std::cout << &Derived::val2 << std::endl; //为什么val2的偏移也是1，难道编译器使用val2的偏移寻址val2的时候,是用sizeof(base1)+val2p偏移作为真正的偏移

【PART - 3】指向 Member 的指针的效率问题

       下面的测试企图获得一些测试数据， 让我们了解， 在 3D 坐标点的各种 class 的实现方式下， 使用指向 members的指针所带来的影响。 一开始的两个例子并没有继承关系， 第一个例子是要取得一个已绑定的 member 的地址：

float *ax = &pA.x;
//施以赋值加法、减法操作
*bx = *ac - *bx;
*by = *ax + *bx;
*bz = *az + *by;

        第二个例子则是针对三个 members， 取得指向 data member 的指针的地址：float Point3d::* ax = &Point3d::_x；而赋值、加法和减法等操作， 都是使用指向 data member 的指针的语法， 把数值绑定到对象 pA 和 pB 中：

pB.*bx = pA.*ax - pB.*bz;
pB.*by = pA.*ay + pB.*bx;
pB.*bz = pA.*az + pB.*by;

        根据具体实验发现， 为每一个 member 存取操作加上一层间接性(经由已绑定的指针)， 会使执行的时间多出一倍不止；以指向 member 的指针来存取数据， 再一次用掉了双倍时间， 要把指向 member 的指针绑定到 class object 的身上， 需要额外的把 offset 减 1。值得注意的是， 在优化之后， 这三种存取效率变得一致， 但只有 NCC 编译器除外。
       简单的说， 不考虑继承时， 优化后除了 NCC 编译器， 其他编译器下三种方式效率相同， 在不优化的前提下，效率： 直接存取 > 使用指针存取 > 使用对象指针存取。

      当考虑继承时， 一般的继承并不影响代码的效率， 但是如果是虚拟继承， 那么因为每一层虚拟继承都导入一个额外层次的间接性， 效率会受到影响。如下：

pB.bx
//会被转换为
&pB->__vbcPoint + ( bx - 1 );
//而不是最直接的
&pb + ( bx - 1);