C++虚函数学习

痛定思痛。 2022-11-15 11:59 195阅读 0赞

先实际操作看看虚函数的作用，就更容易理解概念了；

#include <iostream>
    using namespace std;
    class Base1 { 
    public:
                virtual void f() {  cout << "Base1::f" << endl; }
                virtual void g() {  cout << "Base1::g" << endl; }
                virtual void h() {  cout << "Base1::h" << endl; }
    };
    class Base2 { 
    
    public:
                virtual void f() {  cout << "Base2::f" << endl; }
                virtual void g() {  cout << "Base2::g" << endl; }
                virtual void h() {  cout << "Base2::h" << endl; }
    }; 
    
    class Base3 { 
    public:
    
                virtual void f() {  cout << "Base3::f" << endl; }
    
                virtual void g() {  cout << "Base3::g" << endl; }
    
                virtual void h() {  cout << "Base3::h" << endl; }
    
    };
    
    class Derive : public Base1, public Base2, public Base3 { 
    
    public:
    
                virtual void f() {  cout << "Derive::f" << endl; }
    
                virtual void g1() {  cout << "Derive::g1" << endl; }
    
    };
    
    typedef void(*Fun)(void);
    
    int main()
    
    { 
    
                Fun pFun = NULL;
                Derive d;
                int** pVtab = (int**)&d;
    
                //Base1's vtable
    
                //pFun = (Fun)*((int*)*(int*)((int*)&d+0)+0);
    
                pFun = (Fun)pVtab[0][0];
    
                pFun();
    
                //pFun = (Fun)*((int*)*(int*)((int*)&d+0)+1);
    
                pFun = (Fun)pVtab[0][1];
    
                pFun();
    
                //pFun = (Fun)*((int*)*(int*)((int*)&d+0)+2);
    
                pFun = (Fun)pVtab[0][2];
    
                pFun();
    
                //Derive's vtable
    
                //pFun = (Fun)*((int*)*(int*)((int*)&d+0)+3);
    
                pFun = (Fun)pVtab[0][3];
    
                pFun();
    
                //The tail of the vtable
    
                pFun = (Fun)pVtab[0][4];
    
                cout<<pFun<<endl;
    
                //Base2's vtable
    
                //pFun = (Fun)*((int*)*(int*)((int*)&d+1)+0);
    
                pFun = (Fun)pVtab[1][0];
    
                pFun();
    
                //pFun = (Fun)*((int*)*(int*)((int*)&d+1)+1);
    
                pFun = (Fun)pVtab[1][1];
    
                pFun();
    
                pFun = (Fun)pVtab[1][2];
    
                pFun();
    
                //The tail of the vtable
    
                pFun = (Fun)pVtab[1][3];
    
                cout<<pFun<<endl;
    
                //Base3's vtable
    
                //pFun = (Fun)*((int*)*(int*)((int*)&d+1)+0);
    
                pFun = (Fun)pVtab[2][0];
    
                pFun();
    
                //pFun = (Fun)*((int*)*(int*)((int*)&d+1)+1);
    
                pFun = (Fun)pVtab[2][1];
    
                pFun();
    
                pFun = (Fun)pVtab[2][2];
    
                pFun();
    
                //The tail of the vtable
    
                pFun = (Fun)pVtab[2][3];
    
                cout<<pFun<<endl;
    
                return 0;
    
    }

**虚函数**  
***虚函数 是在基类中使用关键字 virtual 声明的函数。在派生类中重新定义基类中定义的虚函数时，会告诉编译器不要静态链接到该函数。***

我们想要的是在程序中任意点可以根据所调用的对象类型来选择调用的函数，这种操作被称为动态链接，或后期绑定。

**纯虚函数**  
您可能想要在基类中定义虚函数，以便在派生类中重新定义该函数更好地适用于对象，但是您在基类中又不能对虚函数给出有意义的实现，这个时候就会用到纯虚函数。

我们可以把基类中的虚函数 area() 改写如下：

class Shape { 
       protected:
          int width, height;
       public:
          Shape( int a=0, int b=0)
          { 
             width = a;
             height = b;
          }
          // pure virtual function
          virtual int area() = 0;
    };

= 0 告诉编译器，函数没有主体，上面的虚函数是纯虚函数

\*\*

## 虚函数表实现原理 ##

\*\*  
虚函数的实现是由两个部分组成的，虚函数指针与虚函数表。  
虚函数指针 (virtual function pointer) 从本质上来说就只是一个指向函数的指针，与普通的指针并无区别。它指向用户所定义的虚函数，具体是在子类里的实现，当子类调用虚函数的时候，实际上是通过调用该虚函数指针从而找到接口。

虚函数指针是确实存在的数据类型，在一个被实例化的对象中，它总是被存放在该对象的地址首位，这种做法的目的是为了保证运行的快速性。与对象的成员不同，虚函数指针对外部是完全不可见的，除非通过直接访问地址的做法或者在DEBUG模式中，否则它是不可见的也不能被外界调用。

只有拥有虚函数的类才会拥有虚函数指针，每一个虚函数也都会对应一个虚函数指针。所以拥有虚函数的类的所有对象都会因为虚函数产生额外的开销，并且也会在一定程度上降低程序速度。与JAVA不同，C++将是否使用虚函数这一权利交给了开发者，所以开发者应该谨慎的使用。

## 虚函数表 ##

每个类的实例化对象都会拥有虚函数指针并且都排列在对象的地址首部。而它们也都是按照一定的顺序组织起来的，从而构成了一种表状结构，称为虚函数表 (virtual table) 。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zOTMyODQwNg_size_16_color_FFFFFF_t_70]  
C++中一个类是公用一张虚函数表的，基类有基类的虚函数表，子类是子类的虚函数表，这极大的节省了内存

我们先来规定一个基类

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它的虚函数表记录的只有自己定义的虚函数  
![在这里插入图片描述][20210401110731240.png]  
接下来我们来看看子类的情况：  
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;\}  
\}

一般覆盖继承

首先是最常见的继承，子类Derived对基类的虚函数进行覆盖继承，在这个例子中仅设计了一个函数继承的情况以此推广情况。  
![在这里插入图片描述][202104011115534.png]  
那么此时情况是这样的：  
![在这里插入图片描述][20210401111623417.png]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zOTMyODQwNg_size_16_color_FFFFFF_t_70]: /images/20221022/98be6f42af7e45109f6f24c4b71e6084.png
[20210401110731240.png]: /images/20221022/908723ec13784d79a6681ed08685a4a2.png
[202104011115534.png]: https://img-blog.csdnimg.cn/202104011115534.png
[20210401111623417.png]: https://img-blog.csdnimg.cn/20210401111623417.png