＜一＞C++ 对象内存模型——继承

• 单继承模型
• 数据成员、函数成员的继承
• 构造函数、析构函数的调用链
• 子父类对象赋值：注意对象切片效应

• 继承VS. 组合
•内存模型对比
• 组合优于继承

• 多继承模型
• 多继承内存模型

---

单继承内存模型
class Base1{
private:
    int x;
public:
   int y;
   void process()
   {
   }
   /*
     void process(Base1 * p)
     {
     }
   */
};
class Sub1: public Base1{
    double data;

};

void main()
{
   Base b1;
   Sub1 s1;
   b1.process();//编译期绑定 -》 process(&b1)
   s1.process();//编译期绑定 ->  process(&s1)

   对于 Base1 中变量x的是私有的, 在Sub1子类对象中是不可见,但是Sub1子类对象的内存上是存在的!!!
}
//内存模型如下

Sub1 子类的构造函数会自动调用父类的构造函数 类似 Sub1（）: Base1(); 拷贝构造函数和赋值操作符也是一样.

---

关于对象切片
Base1 b1;
Sub1  s1;
b1=s1;//发现对象切片，非常危险
s1=b1;// 不可以

void  function1(Base1  b1)
{
}

void function2(Base1  * b)
{

}

void function3(Base1 & b)
{

}

void main()
{
    Sub1  s1;
    Sub1 * ps1=new Sub1;
    function1(s1);//对象切片
    function2(ps1);//可以 多态
    function3(s1);//也可以 多态
}

---

多继承

多继承内存模型
class Base1{
private:
    int x;
public:
    int y;
};

class Base2{
public:
    int u;
    int v;
};

class Sub2: public Base1, public Base2
{
    double data;
};

---

关于多态, C++ 对象内存模型——多态

• 动态多态的基石——虚函数
• override与final
• 虚函数的内存模型
• 虚函数表结构
• 运行时类型信息（RTTI）
• 虚析构函数：基类析构函数必须为虚，否则会有资源泄漏危险。
• 继承的两层含义
• 实现继承：复用父类定义的数据成员和函数成员
• 接口继承：通过父类定义的虚函数来约定行为合同
• 编译时绑定VS. 运行时绑定

class Base1{

public:
    int y;
    virtual void process()
    {
    }
    ~virtual Base1()
    {
    }
};

class Sub1 : public Base{

public:
   virtual void process() override
   {
   
   }
};

void main()
{
    Base1  b1;
    b1.process();//编译期绑定

    Base1  * sb1=new Sub1();
    sb1.process();//动态绑定，形成多态调用

    delete  sb1;//如果Base1 基类中的析构函数没有写成 虚析构函数,那么delete sb1 会去调用父类的析构函数,不会掉子类的析构函数,内存泄  露风险.
}

关于菱行继承

class Base1{
    double db1;
    double db2;
    double db3;
    double db4;
};
class Sub1: public Base1{
    double d2;
};

class Sub2: public Base1{
    double d3;
};

class Sub3: public Sub1, public Sub2{
    double d4;
};

int main()
{
    cout<<sizeof(Base1)<<endl;//32
    cout<<sizeof(Sub1)<<endl;// 32(B1)+8(S1)=40 
    cout<<sizeof(Sub2)<<endl;// 32(B1)+8(S2)=40  
    cout<<sizeof(Sub3)<<endl; // 32(B1) + 8(S1) + 32(B1) + 8(S2) + 8(S3)=88
}
该方式内存模型中, Sub1中有 一份Base1 内存， Sub2中也有一份Base1内存, Sub3中有两份  Base1内存大小 ，
这种情况典型使用虚继承的场景,改造如下

----------虚继承------------

class Base1{
    double db1;
    double db2;
    double db3;
    double db4;
};
class Sub1: public virtual  Base1{
    double d2;
};

class Sub2:  virtual public Base1{
    double d3;
};

class Sub3: public Sub1, public Sub2{
    double d4;
};

int main()
{
    cout<<sizeof(Base1)<<endl;//32
    cout<<sizeof(Sub1)<<endl;// 32(B1)+8(S1)+8(vb*)=40 
    cout<<sizeof(Sub2)<<endl;// 32(B1)+8(S2)+8(vb*)=40  
    cout<<sizeof(Sub3)<<endl; // 32(B1)+8(S1)+8(S2)+8(S1vb*)+8(S2vb*)+8(S3)=72
}
该方式内存模型中, Sub1中除了有一份Base1内存还多了一个内存指针， Sub2中也有一份Base1内存和一个内存指针,
 Sub3中只有一份Base1内存大小 ,两份指针，内存结构图如下