从内存模型的角度来看C++多态实现机制和C++析构函数为什么要用虚函数

小咪咪 2022-06-03 22:08 125阅读 0赞

# 一、从内存模型角度来看C++多态实现机制 #

\[cpp\] [view plain][] [copy][view plain]

1.  \#include<iostream>
2.  \#include <string>
3.  \#include <stdio.h>
4.  **using****namespace** std; 
5.  
6.  **class** Animal 
7.  \{ 
8.  **public**: 
9.   Animal(**int** a = 1, **int** b = 2) 
10.  \{ 
11. **this**\->a = a; 
12. **this**\->b = b; 
13.  \} 
14. 
15. **virtual****void** sleep(**int** minutes = 30) 
16.  \{ 
17.  cout<<"animal sleep "<<minutes<<" minutes"<<endl; 
18.  \} 
19. **virtual****void** breathe() 
20.  \{ 
21.  cout<<"animal breathe"<<endl; 
22.  \} 
23. **virtual****void** eat() 
24.  \{ 
25.  cout<<"animal eat"<<endl; 
26.  \} 
27. **private**: 
28. **int** a; 
29. **int** b; 
30. \}; 
31. 
32. 
33. **class** Fish:**public** Animal 
34. \{ 
35. **public**: 
36. 
37.  Fish(**int** c) \{ 
38. **this**\->c = c; 
39.  \} 
40. 
41. **virtual****void** breathe() 
42.  \{ 
43.  cout<<"fish breathe"<<endl; 
44.  \} 
45. 
46. **virtual****void** sleep(**int** minutes = 50) 
47.  \{ 
48.  cout<<"fish sleep "<<minutes<<" minutes"<<endl; 
49.  \} 
50. **virtual****void** swim(**void**) //Fish子类特有函数
51.  \{ 
52.  cout<<"fish swim"<<endl; 
53.  \} 
54. **private**: 
55. **int** c; 
56. \}; 
57. 
58. 
59. 
60. **int** main() 
61. \{ 
62. **typedef****void** (\*Fun1)(**void**); //指向breathe()函数
63.  Fun1 pFun1 = NULL; 
64. **typedef****void** (\*Fun2)(**int**); //指向sleep()函数
65.  Fun2 pFun2 = NULL; 
66. 
67.  cout<<"<<<<<<Animal 对象打印信息>>>>>>"<<endl; 
68.  Animal an(1,2); 
69. cout<<"Animal类虚函数表地址："<<(**int**\*)\*(**int**\*)&an<<endl; 
70.  cout<<"对象an内存模型中成员变量a = "<<\* ((**int**\*)&an+1)<<endl; 
71.  cout<<"对象an内存模型中成员变量b = "<<\* ((**int**\*)&an+2)<<endl; 
72. pFun1 = (Fun1)\*(**int**\*)\*(**int**\*)&an; 
73.  pFun1(); 
74. pFun2 = (Fun2)\*((**int**\*)\*(**int**\*)&an+1); 
75. pFun2(50); 
76. pFun1 = (Fun1)\*((**int**\*)\*(**int**\*)&an+2); 
77. pFun1(); 
78. cout<<"<<<<<<Fish 对象打印信息>>>>>>"<<endl; 
79.  Fish fh(5); 
80. 
81.  cout<<"Fish类虚函数表地址：" <<(**int**\*)\*(**int**\*)&fh<<endl; 
82.  cout<<"对象fh内存模型中成员变量a = "<<\* ((**int**\*)&fh+1)<<endl; 
83.  cout<<"对象fh内存模型中成员变量b = "<<\* ((**int**\*)&fh+2)<<endl; 
84.  cout<<"对象fh内存模型中成员变量c = "<<\* ((**int**\*)&fh+3)<<endl; 
85. pFun1 = (Fun1)\*(**int**\*)\*(**int**\*)&fh; 
86.  pFun1(); 
87. pFun2 = (Fun2)\*((**int**\*)\*(**int**\*)&fh+1); 
88. pFun2(50); 
89. pFun1 = (Fun1)\*((**int**\*)\*(**int**\*)&fh+2); 
90.  pFun1(); 
91. pFun1 = (Fun1)\*((**int**\*)\*(**int**\*)&fh+3); 
92.  pFun1(); 
93. cout<<"<<<<<<Animal指针指向Fish 对象打印信息>>>>>>"<<endl; 
94. Animal \*anPtr = &fh; 
95. 
96. cout<<"Animal类指针指向Fish类虚函数表地址：" << (**int**\*)\*(**int**\*)anPtr<<endl; 
97.  cout<<"Animal类指针指向Fish类所属内存区域a = "<<\* ((**int**\*)anPtr+1)<<endl; 
98.  cout<<"Animal类指针指向Fish类所属内存区域b = "<<\* ((**int**\*)anPtr+2)<<endl; 
99. pFun1 = (Fun1)\*(**int**\*)\*(**int**\*)anPtr; 
100.  pFun1(); 
101. pFun2 = (Fun2)\*((**int**\*)\*(**int**\*)anPtr+1); 
102. pFun2(50); 
103. pFun1 = (Fun1)\*((**int**\*)\*(**int**\*)anPtr+2); 
104.  pFun1(); 
105.  pFun1 = (Fun1)\*((**int**\*)\*(**int**\*)anPtr+3); 
106.  pFun1(); 
107. **return** 0; 
108. \}

<<<<<<Animal 对象打印信息>>>>>>  
Animal类虚函数表地址：0x8049178  
对象an内存模型中成员变量a = 1  
对象an内存模型中成员变量b = 2  
animal sleep 134514480 minutes  
animal breathe  
animal eat  
<<<<<<Fish 对象打印信息>>>>>>  
Fish类虚函数表地址：0x8049160  
对象fh内存模型中成员变量a = 1  
对象fh内存模型中成员变量b = 2  
对象fh内存模型中成员变量c = 5  
fish sleep 134514480 minutes  
fish breathe  
animal eat  
fish swim  
<<<<<<Animal指针指向Fish 对象打印信息>>>>>>  
Animal类指针指向Fish类虚函数表地址：0x8049160  
Animal类指针指向Fish类所属内存区域a = 1  
Animal类指针指向Fish类所属内存区域b = 2  
fish sleep 134514480 minutes  
fish breathe  
animal eat  
fish swim  
  
由此可以得到，Animal类an对象与Fish类fh对象的内存布局如下：

![Center][]

**如果一个类声明了虚函数，编译器就会在其声明的对象中的开始部分增加一个指向虚函数表指针vfptr。此实例中 Animal\* anPtr 声明了一个指向Animal对象的指针，当Animal没有声明虚函数时，anPtr所指向的内容并不包括vfptr，当用Fish对象给它赋值时，只将 Fish中的Animal对象复制给anPtr所指向的Animal对象。因此anPtr->breathe()会调用Animal中的breathe()函数。**

**如果Animal中的breathe()是虚函数，那么当Animal \*anPtr = &fh(或者Animal \*anPtr = new Fish(5);)执行时，就会把Fish对象的vfptr 和Fish 对象中包含的Animal对象一同复制给anPtr所指向的对象。此后，anPtr所指向的vfptr 是Fish对象的vfptr，因此再调用anPtr->breathe()时，就会调用Fish类中的breathe()函数。**

总结：对于虚函数调用来说，每一个对象内部都有一个虚表指针，该虚表指针被初始化为本类的虚表。在程序中，不管你的对象类型如何转换，该对象内部的虚表指针都是固定的，所以，才能实现动态的对象函数调用，这就是C++多态性实现的原理。此外，我们还可以看到，对于访问限定符仅仅作用在编译器层面上的，编译器制定了私有的成员变量不能被继承规则，然而在父类和子类的内存模型中可以看到，子类是在父类已有的内存模型空间中增加子类自有的成员变量。

**其特点为：**

**1. 每一个类都有虚表。**

**2. 虚表可以继承，如果子类没有重写虚函数，那么子类虚表中仍然会有该函数的地址，只不过这个地址指向的是基类的虚函数实现。如果重写了相应的虚函数，那么虚表中的地址就会改变，指向自身的虚函数实现。**

**3. 派生类的虚表中虚函数地址的排列顺序和基类的虚表中虚函数地址排列顺序相同。**

# 二、C++析构函数为什么要为虚函数 #

1.为什么基类的析构函数是虚函数？

在公有继承中,基类对派生类及其对象的操作,只能影响到那些从基类继承下来的成员.如果想要用基类对非继承成员进行操作,则要把基类的这个函数定义为虚函数.

在实现多态时，当用基类操作派生类，在析构时防止只析构基类而不析构派生类的状况发生。

a.第一段代码

![复制代码][copycode.gif]

[![复制代码][copycode.gif 1]][copycode.gif 1 1]

#include<iostream>
    using namespace std;
    class ClxBase{
    public:
        ClxBase() {};
        ~ClxBase() {cout << "Output from the destructor of class ClxBase!" << endl;};
    
        void DoSomething() { cout << "Do something in class ClxBase!" << endl; };
    };
    
    class ClxDerived : public ClxBase{
    public:
        ClxDerived() {};
        ~ClxDerived() { cout << "Output from the destructor of class ClxDerived!" << endl; };
    
        void DoSomething() { cout << "Do something in class ClxDerived!" << endl; };
    };
      int   main(){  
      ClxDerived *p =  new ClxDerived;
      p->DoSomething();
      delete p;
      return 0;
      }

[![复制代码][copycode.gif 1]][copycode.gif 1 1]

![复制代码][copycode.gif]

运行结果：

Do something in class ClxDerived!

Output from the destructor of class ClxDerived!

Output from the destructor of class ClxBase!

这段代码中基类的析构函数不是虚函数,在main函数中用继承类的指针去操作继承类的成员,释放指针P的过程是:先释放继承类的资源,再释放基类资源.

b.第二段代码

![复制代码][copycode.gif]

[![复制代码][copycode.gif 1]][copycode.gif 1 1]

#include<iostream>
    using namespace std;
    class ClxBase{
    public:
        ClxBase() {};
        ~ClxBase() {cout << "Output from the destructor of class ClxBase!" << endl;};
    
        void DoSomething() { cout << "Do something in class ClxBase!" << endl; };
    };
    
    class ClxDerived : public ClxBase{
    public:
        ClxDerived() {};
        ~ClxDerived() { cout << "Output from the destructor of class ClxDerived!" << endl; };
    
        void DoSomething() { cout << "Do something in class ClxDerived!" << endl; }
    };
      int   main(){  
      ClxBase *p =  new ClxDerived;
      p->DoSomething();
      delete p;
      return 0;
      }

[![复制代码][copycode.gif 1]][copycode.gif 1 1]

![复制代码][copycode.gif]

输出结果：

Do something in class ClxBase!  
　　Output from the destructor of class ClxBase!

这段代码中基类的析构函数同样不是虚函数,不同的是在main函数中用基类的指针去操作继承类的成员,释放指针P的过程是:只是释放了基类的资源,而没有调用继承类的析构函数.调用　　dosomething()函数执行的也是基类定义的函数.

一般情况下,这样的删除只能够删除基类对象,而不能删除子类对象,形成了删除一半形象,造成内存泄漏.

析构函数自然也应该如此:如果它想析构子类中的重新定义或新的成员及对象,当然也应该声明为虚的.

c.第三段代码：

![复制代码][copycode.gif]

[![复制代码][copycode.gif 1]][copycode.gif 1 1]

#include<iostream>
    using namespace std;
    class ClxBase{
    public:
        ClxBase() {};
        virtual ~ClxBase() {cout << "Output from the destructor of class ClxBase!" << endl;};
        virtual void DoSomething() { cout << "Do something in class ClxBase!" << endl; };
    };
    
    class ClxDerived : public ClxBase{
    public:
        ClxDerived() {};
        ~ClxDerived() { cout << "Output from the destructor of class ClxDerived!" << endl; };
        void DoSomething() { cout << "Do something in class ClxDerived!" << endl; };
    };
    
      int   main(){  
      ClxBase *p =  new ClxDerived;
      p->DoSomething();
      delete p;
      return 0;
      }

[![复制代码][copycode.gif 1]][copycode.gif 1 1]

![复制代码][copycode.gif]

运行结果：

Do something in class ClxDerived!  
　　Output from the destructor of class ClxDerived!  
　　Output from the destructor of class ClxBase!

这段代码中基类的析构函数被定义为虚函数,在main函数中用基类的指针去操作继承类的成员,释放指针P的过程是:只是释放了继承类的资源,再调用基类的析构函数.调用dosomething()函数执行的也是继承类定义的函数.

如果不需要基类对派生类及对象进行操作,则不能定义虚函数,因为这样会增加内存开销.当类里面有定义虚函数的时候,编译器会给类添加一个虚函数表,里面来存放虚函数指针,这样就会增加类的存储空间.所以,只有当一个类被用来作为基类的时候,才把析构函数写成虚函数.

[view plain]: http://blog.csdn.net/sunjunior/article/details/38502335#
[Center]: /images/20220604/59d7e91c615b489c92f1470fa1f27272.png
[copycode.gif]: /images/20220604/21f58683e0fe4052a3d21fb1f96adb6f.png
[copycode.gif 1]: http://common.cnblogs.com/images/copycode.gif
[copycode.gif 1 1]: /images/20220604/177e1a0d97da49cc9a0c25487db3b72c.png