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

Posted 2022-06-15 chusiyong

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

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

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

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

• 类对象在内存中的分布和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