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

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

• 对于一个对象而言，成员变量和成员函数是分开存放的
  • 成员函数位于代码段，所有的类对象共有
  • 成员变量为每一个对象独有，位于内存中
• 类对象在内存中的分布和struct完全相同
• 对于继承，子类的对象是在父类的对象的基础上，加上子类自己的成员

 1 #include <iostream>
 2 #include <string>
 3
 4 using namespace std;
 5
 6 class Test
 7 {
 8     int mi;
 9 public:
10     Test(int i = 0)  //转换构造函数
11     {
12         mi = i;
13     }
14
15     void showMI()
16     {
17         cout<<"Test mi = "<< mi <<endl;
18     }
19 };
20
21 class Test1: public Test
22 {
23     int mj;
24 public:
25     Test1(int j = 0)
26     {
27         mj = j;
28     }
29
30     void showMJ()
31     {
32         cout<<"Test mj = "<< mj <<endl;
33     }
34 };
35
36 struct T    //T的结构和Test2的内存结构完全相同
37 {
38     int mi;
39     int mj;
40 };
41
42 int main()
43 {
44     Test2 t;
45
46     T *p = reinterpret_cast<T *>(&t);
47     p->mi = 1;
48     p->mj = 2;
49
50     t.showMI();
51     t.showMJ();
52
53     return 0;
54 }

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

 1 #include <iostream>
 2 #include <string>
 3
 4 using namespace std;
 5
 6 class Test
 7 {
 8     int mi;
 9 public:
10     Test(int i = 0)  //转换构造函数
11     {
12         mi = i;
13     }
14
15     virtual void showMI()
16     {
17         cout<<"Test mi = "<< mi <<endl;
18     }
19 };
20
21 class Test1: public Test
22 {
23     int mj;
24 public:
25     Test1(int j = 0)
26     {
27         mj = j;
28     }
29
30     virtual void showMJ()
31     {
32         cout<<"Test mj = "<< mj <<endl;
33     }
34 };
35
36 struct T    //T的结构和Test2的内存结构完全相同
37 {
38     void *p;
39     int mi;
40     int mj;
41 };
42
43 int main()
44 {
45     Test2 t;
46
47     T *p = reinterpret_cast<T *>(&t);
48     p->mi = 1;
49     p->mj = 2;
50
51     t.showMI();
52     t.showMJ();
53
54     return 0;
55 }

• 对于多继承(不建议使用)，按照继承时声明的顺序依次叠加父类的情况，最后跌倒子类自己的成员
  • https://www.cnblogs.com/longcnblogs/archive/2017/10/09/7642951.html
  • 如果继承的父类都有虚函数，那么子类中有多个指向虚函数函数表的指针

 1 #include <iostream>
 2 #include <string>
 3
 4 using namespace std;
 5
 6 class Test
 7 {
 8     int mi;
 9 public:
10     Test(int i = 0)  //转换构造函数
11     {
12         mi = i;
13     }
14
15     virtual void showMI()
16     {
17         cout<<"Test mi = "<< mi <<endl;
18     }
19 };
20
21 class Test1
22 {
23     int mj;
24 public:
25     Test1(int j = 0)
26     {
27         mj = j;
28     }
29
30     virtual void showMJ()
31     {
32         cout<<"Test mj = "<< mj <<endl;
33     }
34 };
35
36 class Test2 : public Test, public Test1
37 {
38     int mk;
39 public:
40     Test2(int k = 0)
41     {
42         mk = k;
43     }
44
45     void showMK()   //增加了虚函数
46     {
47         cout<<"Test mk = "<< mk <<endl;
48     }
49 };
50
51 struct T    //T的结构和Test2的内存结构完全相同
52 {
53     void *p;   //多了一个指向虚函数表的指针
54     int mi;
55     void *p1;  //多了一个指向虚函数表的指针
56     int mj;
57     int mk;
58 };
59
60 int main()
61 {
62     Test2 t;
63
64     T *p = reinterpret_cast<T *>(&t);
65     p->mi = 1;
66     p->mj = 2;
67     p->mk = 3;
68
69     t.showMI();
70     t.showMJ();
71     t.showMK();
72
73     return 0;
74 }

原文地址：https://www.cnblogs.com/chusiyong/p/11311268.html