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

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

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

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

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

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

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

 #include <iostream>
 #include <string>

 using namespace std;

 class Test
 {
     int mi;
 public:
     Test(int i = )  //转换构造函数
     {
         mi = i;
     }

     void showMI()
     {
         cout<<"Test mi = "<< mi <<endl;
     }
 };

 class Test1: public Test
 {
     int mj;
 public:
     Test1(int j = )
     {
         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 = ;
     p->mj = ;

     t.showMI();
     t.showMJ();

     return ;
 }

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

 #include <iostream>
 #include <string>

 using namespace std;

 class Test
 {
     int mi;
 public:
     Test(int i = )  //转换构造函数
     {
         mi = i;
     }

     virtual void showMI()
     {
         cout<<"Test mi = "<< mi <<endl;
     }
 };

 class Test1: public Test
 {
     int mj;
 public:
     Test1(int j = )
     {
         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 = ;
     p->mj = ;

     t.showMI();
     t.showMJ();

     return ;
 }

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

  • 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 = )  //转换构造函数
     {
         mi = i;
     }

     virtual void showMI()
     {
         cout<<"Test mi = "<< mi <<endl;
     }
 };

 class Test1
 {
     int mj;
 public:
     Test1(int j = )
     {
         mj = j;
     }

     virtual void showMJ()
     {
         cout<<"Test mj = "<< mj <<endl;
     }
 };

 class Test2 : public Test, public Test1
 {
     int mk;
 public:
     Test2(int k = )
     {
         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 = ;
     p->mj = ;
     p->mk = ;

     t.showMI();
     t.showMJ();
     t.showMK();

     return ;
 }