虚函数及继承

╰+攻爆jí腚メ 2022-08-05 11:17 186阅读 0赞

1.  \#include <iostream>  
    
2.  using namespace std;  
    
3.    
    
4.  class Base1  
    
5.  \{   
    
6.    
    
7.  \};  
    
8.    
    
9.  class Base2  
    
10. \{   
    
11.   
    
12. \};  
    
13.   
    
14. class Derived1:public Base1  
    
15. \{   
    
16.   
    
17. \};  
    
18.   
    
19. class Derived2:public Base1, public Base2  
    
20. \{   
    
21.   
    
22. \};  
    
23.   
    
24. int main()  
    
25. \{   
    
26.     Base1 b1;  
    
27.     Base2 b2;  
    
28.     Derived1 d1;  
    
29.     Derived2 d2;  
    
30.     cout<<"sizeof(Base1) = "<<sizeof(Base1)<<" sizeof(b1) = "<<sizeof(b1)<<endl;  
    
31.      cout<<"sizeof(Base2) = "<<sizeof(Base2)<<" sizeof(b2) = "<<sizeof(b2)<<endl;  
    
32.     cout<<"sizeof(Derived1) = "<<sizeof(Derived1)<<" sizeof(d1) = "<<sizeof(d1)<<endl;  
    
33.     cout<<"sizeof(Derived2) = "<<sizeof(Derived2)<<" sizeof(d1) = "<<sizeof(d1)<<endl;  
    
34.     
    
35.     return 0;  
    
36. \}
37. 结果为：

sizeof(Base1) = 1 sizeof(b1) = 1  
sizeof(Base2) = 1 sizeof(b2) = 1  
sizeof(Derived1) = 1 sizeof(d1) = 1  
sizeof(Derived2) = 1 sizeof(d1) = 1  
可以看出所有的结果都是1。

2、含有虚函数的类以及虚继承类的sizeof

虚函数（Virtual Function）是通过一张虚函数表（Virtual Table）来实现的。编译器必需要保证虚函数表的指针存在于对象实例中最前面的位置（这是为了保证正确取到虚函数的偏移量）。

假设我们有这样的一个类：

class Base \{

public:

virtual void f() \{ cout << "Base::f" << endl; \}

virtual void g() \{ cout << "Base::g" << endl; \}

virtual void h() \{ cout << "Base::h" << endl; \}

\};

当我们定义一个这个类的实例，Base b时，其b中成员的存放如下：

[![25132162_1309508414SdSf.jpg][]][25132162_1309508414SdSf.jpg]指向虚函数表的指针在对象b的最前面。

虚函数表的最后多加了一个结点，这是虚函数表的结束结点，就像字符串的结束符“\\0”一样，其标志了虚函数表的结束。这个结束标志的值在不同的编译器下是不同的。在WinXP+VS2003下，这个值是NULL。而在Ubuntu 7.10 + Linux 2.6.22 + GCC 4.1.3下，这个值是如果1，表示还有下一个虚函数表，如果值是0，表示是最后一个虚函数表。

因为对象b中多了一个指向虚函数表的指针，而指针的sizeof是4，因此含有虚函数的类或实例最后的sizeof是实际的数据成员的sizeof加4。

下面将讨论针对基类含有虚函数的继承讨论

（1）在派生类中不对基类的虚函数进行覆盖，同时派生类中还拥有自己的虚函数，比如有如下的派生类：

class Derived: public Base

public:

virtual void f1() \{ cout << "Derived::f1" << endl; \}

virtual void g1() \{ cout << "Derived::g1" << endl; \}

virtual void h1() \{ cout << "Derived::h1" << endl; \}

\};

基类和派生类的关系如下：

[![25132162_1309508913JJL4.jpg][]][25132162_1309508913JJL4.jpg]

当定义一个Derived的对象d后，其成员的存放如下：

[![25132162_13095089486Q1S.jpg][]][25132162_13095089486Q1S.jpg]

可以发现：

1）虚函数按照其声明顺序放于表中。

2）父类的虚函数在子类的虚函数前面。

此时基类和派生类的sizeof都是数据成员的sizeof加4。

（2）在派生类中对基类的虚函数进行覆盖，假设有如下的派生类：

class Derived: public Base

public:

virtual void f() \{ cout << "Derived::f" << endl; \}

virtual void g1() \{ cout << "Derived::g1" << endl; \}

virtual void h1() \{ cout << "Derived::h1" << endl; \}

\};

基类和派生类之间的关系：其中基类的虚函数f在派生类中被覆盖了

[![25132162_1309509166FMTD.jpg][]][25132162_1309509166FMTD.jpg]

当我们定义一个派生类对象d后，其d的成员存放为：

[![25132162_1309509234Ui08.jpg][]][25132162_1309509234Ui08.jpg]

可以发现：

1）覆盖的f()函数被放到了虚表中原来父类虚函数的位置。

2）没有被覆盖的函数依旧。

这样，我们就可以看到对于下面这样的程序，

Base \*b = new Derive();

b->f();

由b所指的内存中的虚函数表的f()的位置已经被Derive::f()函数地址所取代，于是在实际调用发生时，是Derive::f()被调用了。这就实现了多态。

（3）多继承：无虚函数覆盖

假设基类和派生类之间有如下关系：

[![25132162_1309509398QKlQ.jpg][]][25132162_1309509398QKlQ.jpg]

对于子类实例中的虚函数表，是下面这个样子：

![o_vtable4.JPG][]

我们可以看到：

1） 每个父类都有自己的虚表。

2） 子类的成员函数被放到了第一个父类的表中。（所谓的第一个父类是按照声明顺序来判断的）

由于每个基类都需要一个指针来指向其虚函数表，因此d的sizeof等于d的数据成员加3\*4=12。

（4）多重继承，含虚函数覆盖

假设，基类和派生类又如下关系：派生类中覆盖了基类的虚函数f

[![25132162_13095095672p6I.jpg][]][25132162_13095095672p6I.jpg]

下面是对于子类实例中的虚函数表的图：

![o_vtable5.jpg][]

我们可以看见，三个父类虚函数表中的f()的位置被替换成了子类的函数指针。这样，我们就可以任一静态类型的父类来指向子类，并调用子类的f()了。如：

Derive d;

Base1 \*b1 = &d;

Base2 \*b2 = &d;

Base3 \*b3 = &d;

b1->f(); //Derive::f()

b2->f(); //Derive::f()

b3->f(); //Derive::f()

b1->g(); //Base1::g()

b2->g(); //Base2::g()

b3->g(); //Base3::g()

3、一个关于含虚函数及虚继承的sizeof计算

1.  \#include  <iostream>  
    
2.  using namespace std;  
    
3.    
    
4.  class Base  
    
5.  \{   
    
6.  public:  
    
7.      virtual void f();  
    
8.      virtual void g();  
    
9.      virtual void h();  
    
10. \};  
    
11.   
    
12. class Derived1: public Base  
    
13. \{   
    
14. public:  
    
15.     virtual void f1();  
    
16.     virtual void g1();  
    
17.     virtual void h1();  
    
18. \};  
    
19.   
    
20. class Derived2:public Base  
    
21. \{   
    
22. public:  
    
23.     virtual void f();  
    
24.     virtual void g1();  
    
25.     virtual void h1();  
    
26. \};  
    
27.   
    
28. class Derived3:virtual public Base  
    
29. \{   
    
30. public:  
    
31.     virtual void f1();  
    
32.     virtual void g1();  
    
33.     virtual void h1();  
    
34. \};  
    
35.   
    
36. class Derived4:virtual public Base  
    
37. \{   
    
38. public:  
    
39.     virtual void f();  
    
40.     virtual void g1();  
    
41.     virtual void h1();  
    
42. \};  
    
43.   
    
44. class Derived5:virtual public Base  
    
45. \{   
    
46. public:  
    
47.     virtual void f();  
    
48.     virtual void g();  
    
49.     virtual void h();  
    
50. \};  
    
51.   
    
52. class Derived6:virtual public Base  
    
53. \{   
    
54.   
    
55. \};  
    
56.   
    
57. int main()  
    
58. \{   
    
59.     cout<<sizeof(Base)<<endl; //4  
    
60.     cout<<sizeof(Derived1)<<endl; //4  
    
61.     cout<<sizeof(Derived2)<<endl; //4  
    
62.     cout<<sizeof(Derived3)<<endl; //12  
    
63.     cout<<sizeof(Derived4)<<endl; //12  
    
64.     cout<<sizeof(Derived5)<<endl; //8  
    
65.     cout<<sizeof(Derived6)<<endl; //8  
    
66.   
    
67.     return 0;  
    
68. \}

对于Base, Derived1和Derived2的结果根据前面关于继承的分析是比较好理解的，不过对于虚继承的方式则有点不一样了，根据结果自己得出的一种关于虚继承的分析，如对Derived3或Derived4定义一个对象d,其里面会出现三个跟虚函数以及虚继承的指针，因为是虚继承，因此引入一个指针指向虚继承的基类，第二由于在基类中有虚函数，因此需要指针指向其虚函数表，由于派生类自己本身也有自己的虚函数，因为采取的是虚继承，因此它自己的虚函数不会放到基类的虚函数表的后面，而是另外分配一个只存放自己的虚函数的虚函数表，于是又引入一个指针，从例子中看到Derived5和Derived6的结果是8，原因是在派生类要么没有自己的虚函数，要么全部都是对基类虚函数的覆盖，因此就少了指向其派生类自己的虚函数表的指针，故结果要少4。

链接：[http://blog.chinaunix.net/uid-25132162-id-1564955.html][http_blog.chinaunix.net_uid-25132162-id-1564955.html]

[25132162_1309508414SdSf.jpg]: http://blog.chinaunix.net/attachment/201107/1/25132162_1309508414SdSf.jpg
[25132162_1309508913JJL4.jpg]: http://blog.chinaunix.net/attachment/201107/1/25132162_1309508913JJL4.jpg
[25132162_13095089486Q1S.jpg]: http://blog.chinaunix.net/attachment/201107/1/25132162_13095089486Q1S.jpg
[25132162_1309509166FMTD.jpg]: http://blog.chinaunix.net/attachment/201107/1/25132162_1309509166FMTD.jpg
[25132162_1309509234Ui08.jpg]: http://blog.chinaunix.net/attachment/201107/1/25132162_1309509234Ui08.jpg
[25132162_1309509398QKlQ.jpg]: http://blog.chinaunix.net/attachment/201107/1/25132162_1309509398QKlQ.jpg
[o_vtable4.JPG]: /images/20220731/49a35a978016450ea3bf6e4d071b7046.png
[25132162_13095095672p6I.jpg]: http://blog.chinaunix.net/attachment/201107/1/25132162_13095095672p6I.jpg
[o_vtable5.jpg]: /images/20220731/ad6eae13ca514ca1a992606b601af237.png
[http_blog.chinaunix.net_uid-25132162-id-1564955.html]: http://blog.chinaunix.net/uid-25132162-id-1564955.html