C++对象模型的一点理解

 这两天一直在研究对象模型的问题，发现这个问题确实不好理解，但通过反汇编，对于汇编下，数据段，代码段有了一定的认识。
经过两天的研究测试发现当一个类被定义了之后，数据和函数是分离的，函数是放在断码段的，函数名标示函数的起始地址，往下就是函数内部的指令
当创建一个类的object时，栈上开辟空间来容纳其中的数据变量，然后调用构造函数来初始化数据成员，如何调用构造函数我至今也不太清楚。。。

#include <iostream>
using namespace std;
class A
{
    public:
    A()
    {
        cout << "A's constructor" << endl;
    }//标记3
    A(int i):a(i){}
    A(const A &orig):a(orig.a)
    {

    }
    A& operator = (const A &orig)
    {
        a = orig.a;
        return *this;
    }
    virtual ~A(){}
    private:
    int a;
};
class B:publicA
{
    public:
    B()
    {
        cout << "B's constructor" << endl;
    }//标记2
    B(int i,int x):A(i),b(x){}
    B(const B &orig):A(orig),b(orig.b)
    {

    }
    B& operator = (const B &orig)
    {
        A::operator = (orig);
        b = orig.b;
        return *this;
    }
    ~B(){}
    private:
    int b;
};
int main()
{
    A *p = new B;//
    return 0;
}

对于上面这段代码通过反汇编发现
0041C94C A()
0041C9D4 ~A()
0041C9FC B()
0041CAEC ~B()
说明代码段中，基类成员函数的位置处于上层，派生类在下层，这和C++继承体系里的scope吻合不是巧然，这说明编译器在查找函数的时候是由下层地址往上层地址去找的。
B类对象模型如下：

------ <<--- this      --------                ----------
|vpt | ------>>       | ~B地址 | <<-----虚表     | A      | <<-----代码段
------                 --------                 ~A
|a   |                                         | ...    |
------                                           B   
|b   |                                         | ~B     |
------                                         ----------

上图是我推测的B类对象的模型，首先创建对象的时候栈上分配一段空间装数据成员，因为有虚函数所以附带一个vpt，指向虚函数表的首地址，这个是B类的虚函数表，这里只有一个虚析构函数，在B类的虚函数表里把A的虚析构函数替换了。
分配空间之后，调用构造函数来初始化变量，这个时候就跳到代码段B()的位置，然后又向上层地址找到A()的位置，执行里面的指令(给a赋值)，然后回到B()，执行里面的指令（给b赋值）
析构的时候，这里析构函数是虚的，然后就根据确切类型，也就是B类，去B类的虚表中找，结果找到了~B()，然后跳到代码段~B()执行完里面的指令在向上层地址找到~A()
如果A的析构函数不是虚的，那么对象模型就完全不同

------ <<--- this     --------   
|a   |                | A    | <<-----代码段   
------                  ~A   
|b   |                | ...  |   
------                  B   
                      | ~B   |
                      --------

这里就没有所谓的虚表了，析构的时候，虚函数不是虚的，调用就不是通过虚表了，这个时候根据静态绑定，这个时候就直接跳到了代码段~A()，然后执行里面的指令，这个时候编译器再不会去找~B()了，因为它在下层地址，结果造成了所谓的内存泄漏  
这些就是我的理解了，就当抛砖引玉吧...