C++语法小记---面向对象模型(实例的内存分布)

面向对象的模型(内存分布)

• 对于一个对象而言，成员变量和成员函数是分开存放的

  • 成员函数位于代码段，所有的类对象共有

  • 成员变量为每一个对象独有，位于内存中

• 类对象在内存中的分布和struct完全相同

• 对于继承，子类的对象是在父类的对象的基础上，加上子类自己的成员

#include <iostream>
#include <string>

using namespace std;

class Test
{
    int mi;
public:
    Test(int i = 0)  //转换构造函数
    {
        mi = i; 
    }
    
    void showMI()
    {
        cout<<"Test mi = "<< mi <<endl;
    }
};

class Test1: public Test
{
    int mj;
public:
    Test1(int j = 0)
    {
        mj = j;
    }
    
    void showMJ()
    {
        cout<<"Test mj = "<< mj <<endl;
    }
};

struct T    //T的结构和Test2的内存结构完全相同
{
    int mi;
    int mj;
};

int main()
{   
    Test2 t;
    
    T *p = reinterpret_cast<T *>(&t);
    p->mi = 1;
    p->mj = 2;
    
    t.showMI();
    t.showMJ();
    
    return 0;
}

• 如果类中有虚函数，那么对象中有一个指向虚函数类表的指针位于每一个对象中

#include <iostream>
#include <string>

using namespace std;

class Test
{
    int mi;
public:
    Test(int i = 0)  //转换构造函数
    {
        mi = i; 
    }
    
    virtual void showMI()
    {
        cout<<"Test mi = "<< mi <<endl;
    }
};

class Test1: public Test
{
    int mj;
public:
    Test1(int j = 0)
    {
        mj = j;
    }
    
    virtual void showMJ()
    {
        cout<<"Test mj = "<< mj <<endl;
    }
};

struct T    //T的结构和Test2的内存结构完全相同
{
    void *p;
    int mi;
    int mj;
};

int main()
{   
    Test2 t;
    
    T *p = reinterpret_cast<T *>(&t);
    p->mi = 1;
    p->mj = 2;
    
    t.showMI();
    t.showMJ();
    
    return 0;
}

• 对于多继承(不建议使用)，按照继承时声明的顺序依次叠加父类的情况，最后跌倒子类自己的成员

  • https://www.cnblogs.com/longcnblogs/archive/2017/10/09/7642951.html

  • 如果继承的父类都有虚函数，那么子类中有多个指向虚函数函数表的指针

#include <iostream>
#include <string>

using namespace std;

class Test
{
    int mi;
public:
    Test(int i = 0)  //转换构造函数
    {
        mi = i; 
    }
    
    virtual void showMI()
    {
        cout<<"Test mi = "<< mi <<endl;
    }
};

class Test1
{
    int mj;
public:
    Test1(int j = 0)
    {
        mj = j;
    }
    
    virtual void showMJ()
    {
        cout<<"Test mj = "<< mj <<endl;
    }
};

class Test2 : public Test, public Test1
{
    int mk;
public:
    Test2(int k = 0) 
    {
        mk = k;
    }
    
    void showMK()   //增加了虚函数
    {
        cout<<"Test mk = "<< mk <<endl;
    }
};

struct T    //T的结构和Test2的内存结构完全相同
{
    void *p;   //多了一个指向虚函数表的指针
    int mi;
    void *p1;  //多了一个指向虚函数表的指针
    int mj;
    int mk;
};

int main()
{   
    Test2 t;
    
    T *p = reinterpret_cast<T *>(&t);
    p->mi = 1;
    p->mj = 2;
    p->mk = 3;
    
    t.showMI();
    t.showMJ();
    t.showMK();
    
    return 0;
}