基类指针变量都被赋值派生类的地址，但为什么不相等呢？

cppfans6

#include <stdio.h>
#include <iostream>
using namespace std;


class A
{
public:
        int n;
        virtual  void fun()
        {
                cout<<"A"<<endl;
        }
};


class B
{
public:
        int n;
        virtual  void fun()
        {
                cout<<"B"<<endl;
        }
};

class C : public A, public B
{
public:
        int n;
        virtual  void fun()
        {
                cout<<"C"<<endl;
        }
};


void main()
{
        C    c;
        A*   pa = &c;
        B*   pb = &c;
        //A*   pa = static_cast<B*>(&b);

        c.fun();
        pa->fun();
        pb->fun();

        cout<<"&c = "<<&c<<endl;
        cout<<"pa = "<<pa<<endl;
        cout<<"pb = "<<pb<<endl;

        return;

}


输出：

C
C
C
&c = 0012FF6C
pa = 0012FF6C
pb = 0012FF74


为什么 &c 和 pa 相等，pb 不等？

twinsen724

问题在于这就是C++的MI模型，这个继承体系的模型可以看作（在内存中）：

A subobject => &c & pa
B subobject => pb
C subobject

对于MI来说，A和B的sub object的起始地址不一样，这不同于SI（SI使用重叠模型）。但C因为继承于A和B，而A是第一个base class，B是第二个base class，在MI中，derived class subobject的起始位置和第一个base class subobject重合，从第二个base class subobject以及之后的，都有自己的独立起始地址。因此

&c == pa == &class A subobject
pb == &class B subobject

根据上面的描述，在MI中，用第二个以及之后的base class pointer保存一个derived class object的地址，compiler需要调整this指针，就在这一步：

B* pb = &c;

this调整到了B subobject的位置，因此造成了你所看到的现象。另外，因为你的hierarchy中有virtual function，这更佳复杂化了MI的内部操作。因为vptr的缘故：

pb->func();

也需要调整this指针，从而指向derived class subobject的地址，实际上就是C object的起始地址&c。

MI是传统C++复杂度的罪魁祸首，如果你再给你的hierarchy加上virtual base class，你会发现自己进入了迷宫。

qinggeng

多重继承的关系？
我不清楚标准里面关于多重继承是怎么规定的，但看样子很像是因为多重继承的关系。
在多重继承的情况下，C在内存中的布局可能是：
_vfptr for A;
A::n;
_vfptr for B;
B::n;
C::n;
所以pa指向的是__vfptr for A, 而pb指向的是 __vfptr for B, 这两个之间还有一个int A::n, 所以差了8个字节。

我对c++的对象模型和多重继承都不清楚，所以只是猜测。

littledick

指针指向的实例都是C类型的啊。{:3_198:}

用基类容器管理多类型子类实例集合时，通常会给子类实例在构造时就标识类型。在使用基类的指针作为容器操作参数，避免最后使用时出错。

linux_c_py_php

i don't know any more, let me go.

cppfans6

linux_c_py_php 发表于 2012-10-08 12:21
就是A类和B类一模一样, 第二个转换其实是将C对象中A对象的地址赋值给B的指针, 对于B指针来说, 因为A对象和B ...

即使A和B的内存布局不一样（如下面），也是同样的啊。

class A
{
public:
        int n;
        int m;
        int k;
        virtual  void fun()
        {
                cout<<"A"<<endl;
        }
};


class B
{
public:
        char  c;
        virtual  void fun()
        {
                cout<<"B"<<endl;
        }
};

linux_c_py_php

就是A类和B类一模一样, 第二个转换其实是将C对象中A对象的地址赋值给B的指针, 对于B指针来说, 因为A对象和B对象的内存布局是一样的, 所以调用B->xxx和调用A->xxx是一样的.

cppfans6 发表于 2012-10-08 12:16
不明白，你这个回答好像不是我要问的，请详解。

cppfans6

linux_c_py_php 发表于 2012-10-08 12:12
前者指向B基类, 后者指向A基类, 最后都是调C派生类, 而且A, B长的一样, 不费解吧.

不明白，你这个回答好像不是我要问的，请详解。

linux_c_py_php

前者指向B基类, 后者指向A基类, 最后都是调C派生类, 而且A, B长的一样, 不费解吧.

cppfans6

linux_c_py_php 发表于 2012-10-08 11:58
B是C的基类, 虚函数不调用C的调用谁的?

这个我知道，我问的是

B*   pb = &c;  和  B*   pb = reinterpret_cast<B*>(&c);

两个pb数值不同，但还都能保证pb->fun(); 调用的是C的fun，编译器怎么处理的?