C++虚函数要点合集

灰太狼 2022-05-28 10:55 205阅读 0赞

参考：  
[https://blog.csdn.net/lihao21/article/details/50688337][https_blog.csdn.net_lihao21_article_details_50688337]

## 1、动态类型与静态类型 ##

**静态类型：**指不需要考虑表达式的执行期语义，仅分析程序文本而决定的表达式类型。静态类型仅依赖于包含表达式的程序文本的形式，而在程序运行时不会改变。通俗的讲，就是上下文无关，在编译时就可以确定其类型。  
**动态类型：**基类的指针和基类引用有可能为动态类型，就是说在运行之前不能够确定其真实类型。通常我们说，“基类指针指向的对象的实际/真正类型”或“基类引用所引用的对象的实际/真正类型”，就是它们的动态类型。很显然，这个动态类型是 C++ 语言通过指针和引用实现运行时多态能力的核心概念。  
**静态绑定：**编译时绑定，通过对象调用的全部是静态绑定在程序运行之前就可以确定其调用的函数。  
**动态绑定：**运行时绑定，通过基类指针或引用调用虚函数时候可理解为动态绑定，C++里面通过虚函数实现动态绑定。

## 2、接口继承、实现继承、非虚函数 ##

基类中函数的类型总共有三种。纯虚函数、虚函数以及非虚函数。  
**纯虚函数**：下面的`draw`就是纯虚函数，使用`Shape`成为一个抽象基类，用户不能创建`Shape`类的实例，只能被继承，并且继承类中必须重定义纯虚函数`draw`，**定义纯虚函数的目的在于使派生类仅仅继承函数的接口，也就是基类仅仅知道需要实现什么功能，但是具体如何实现我不知道啊，你派生类自己实现吧**。

class Shape{
    public:
        virtual void draw()const = 0;//纯虚函数
        virtual void error(const string& msg);//虚函数
        int objectID()const;//非虚函数
        //...
    }
    class Rect:public Shape{
        //...
    }

**2、虚函数：**上述的`error`就是虚函数，简单的虚函数是为了告诉派生类，你必须有这个功能，并且我给你提供了一个默认的实现，你也可以自己重新写这个功能，使派生类继承函数的接口和缺省实现。`Shape::error`的声明是在告诉派生类的设计者， “你必须支持error函数，但如果你不想写自己的版本，可以借助Shape类中的缺省版本。

**3、非虚函数：**上述的`objectID`就是非虚函数，声明非虚函数的目的在于，使派生类继承函数的接口和强制性实现。`Shape::objectID`的声明就是在说， “每个Shape对象有一个函数用来产生对象的标识符，并且对象标识符的产生方式总是一样的。这种方式由`Shape::objectID`的定义决定，派生类不能改变它。” 因为非虚函数表示一种特殊性上的不变性，所以它决不能在子类中被重新定义。

## 3、绝不要重新定义继承而来的非虚函数 ##

class B{
    public:
        void mf();
        //...
    }
    class D:publicB{
    public:
        void mf();//隐藏了B::mf()定义，这是万万不行的天坑
    }
    D x;
    
    B *pB = &x;
    pB->mf();//调用B::mf();
    
    D *pD = &x;
    pD->mf();//调用D::mf();

象`B::mf`和`D::mf`这样的非虚函数是静态绑定的。这意味着，因为`pB`被声明为指向B的指针类型，通过`pB`调用非虚函数时将总是调用那些定义在类 `B`中的函数，即使`pB`指向的是从`B`派生的类的对象。相反，虚函数是动态绑定的，因而不会产生这类问题，如果`mf`是虚函数，通过`pB`或`pD`调用`mf`时都将导致调用`D::mf`，因为 `pB`和`pD`实际上指向的都是类型`D` 的对象。

## 4、虚函数、动态绑定、运行时多态之间的关系 ##

基类和派生类中具有接口相同但实现不同的函数方式即为多态。在C++中是通过虚函数动态绑定实现多态的。  
简单地说，虚函数是动态绑定的基础；动态绑定是实现运行时多态的基础。  
要触发动态绑定，需满足两个条件：  
(1) 只有虚函数才能进行动态绑定，非虚函数不进行动态绑定。  
(2) 必须通过基类类型的引用或指针进行函数调用。  
通过基类指针或基类引用做形参，当实参传入不同的派生类(或基类)的指针或引用，在函数内部触发动态绑定，从而来运行时实现多态。

#include<iostream>
    #include<vector>
    using namespace std;
    class Base {
     public:
     void Print() {
       //静态绑定
       cout << "Print() from Base." << endl;
     }
    
     virtual void Display() {
       cout << "Display() from Base." << endl;
     }
    };
    class Derived1 : public Base {
     public:
    
     void Print() {
       //静态绑定，隐藏了基类同样函数
       cout << "Print() from Derived1." << endl;
     }
    
     void Display() {
       cout << "Display() from Derived2." << endl;
     }
    };
    //通过基类引用作形参实现多态
    void Polymorphic1(Base& b) {
      b.Print();
      b.Display();
    }
    
    //通过基类指针作形参实现多态
    void Polymorphic2(Base* b) {
      b->Print();
      b->Display();
    }
    int main() {
      Base b;
      Derived1 d1;
    
      vector<Base> base_vec;//存储base对象，静态绑定
      base_vec.push_back(b);
      base_vec.push_back(d1);//将d1的base部分送入vector
    
      vector<Base*> base_ptr_vec;//存储base指针，动态绑定
      base_ptr_vec.push_back(&b);
      base_ptr_vec.push_back(&d1);
    
      cout << endl;
      for (int i = 0; i != base_vec.size(); ++i) {
        Polymorphic1(base_vec[i]);
      }//这里因为base_vec存储的都是base对象，所以会静态绑定
    
      cout << endl;
      for (int i = 0; i != base_vec.size(); ++i) {
        Polymorphic2(base_ptr_vec[i]);
      }//动态绑定，依据指向的类型进行动态绑定
      return 0;
    }

![这里写图片描述][70]  
说到底`Polymorphic1`的两个输出必然是`Base`里面的，因为`base_vec`里面存储的都是base对象。所以这里直接进行了静态绑定。`Polymorphic2`第二个`Print`是非虚函数，直接静态绑定了，输出了基类的`Print`，`Display`是虚函数，这里执行了动态绑定，输出基类的`Display`。

## 5、确保基类虚析构函数 ##

C++中基类采用virtual虚析构函数**是为了防止内存泄漏。具体地说，如果派生类中申请了内存空间，并在其析构函数中对这些内存空间进行释放。假设基类中采用的是非虚析构函数，当通过基类指针删除指向的派生类对象时就不会触发动态绑定，因而只会调用（静态绑定）基类的析构函数，而不会调用派生类（动态绑定）的析构函数**。那么在这种情况下，派生类中申请的空间就得不到释放从而产生内存泄漏。所以，为了防止这种情况的发生，C++中基类的析构函数应采用virtual虚析构函数。

#include<iostream>
    using namespace std;
    class Base {
     public:
        ~Base() {
          cout << "~Base()" << endl;
        }
    };
    
    class Derived1 : public Base {
     public:
      Derived1():name_(new string("NULL")) {}
      Derived1(const string& n):name_(new string(n)) {}
    
      ~Derived1() {
        delete name_;
        cout << "~Derived1(): name_ has been deleted." << endl;
      }
    
     private:
      string *name_;
    };
    
    class Derived2 : public Base {
     public:
      Derived2():name_(new string("NULL")) {}
      Derived2(const string& n):name_(new string(n)) {}
    
      ~Derived2() {
        delete name_;
        cout << "~Derived2(): name_ has been deleted." << endl;
      }
    
     private:
      string *name_;
    };
    
    int main() {
      Derived1 *d1 = new Derived1();//存储与堆，必须主动析构释放
      Derived2  d2 = Derived2("Bob");//存储与栈，作用域结束自动析构释放
      delete d1;//静态绑定，必定调用Derived1::~Derived1
      return 0;
    }

![这里写图片描述][70 1]  
Base基类的析构函数并不是虚析构函数，现在结果显示，派生类的析构函数被调用了，正常的释放了其申请的内存资源。这两者并不矛盾，因为无论是d1还是d2，两者**都属于静态绑定，而且其静态类型恰好都是派生类**，因此，在析构的时候，即使基类的析构函数为非虚析构函数，也会调用相应派生类的析构函数。

int main() {
      Base *base[2] = {
        new Derived1(),
        new Derived2("Bob")
      };
      for (int i = 0; i != 2; ++i) {
        delete base[i];//动态绑定，因为析构非虚，所以调用静态绑定
      }
      return 0;
    }

![这里写图片描述][70 2]

尽管派生类中定义了析构函数来释放其申请的资源，但是并没有得到调用。原因是**基类指针指向了派生类对象，而基类中的析构函数却是非virtual的，之前讲过，虚函数是动态绑定的基础**。**现在析构函数不是virtual的，因此不会发生动态绑定，而是静态绑定，指针的静态类型为基类指针，因此在delete时候只会调用基类的析构函数，而不会调用派生类的析构函数**。这样，在**派生类中申请的资源就不会得到释放，就会造成内存泄漏，这是相当危险的：如果系统中有大量的派生类对象被这样创建和销毁，就会有内存不断的泄漏，久而久之，系统就会因为缺少内存而崩溃**。

## 6、虚函数实现原理 ##

**1、类的虚表**  
每个包含了虚函数的类都包含一个虚表。一个类继承了包含虚函数的基类，那么这个类也拥有自己的虚表。每个类只有一个虚表，当声明其对象的时候，仅仅在对象内存空间里面加入指向虚表的指针。  
以下代码中类A包含虚函数vfunc1，vfunc2，由于类A包含虚函数，故类A拥有一个虚表。

class A {
    public:
        virtual void vfunc1();
        virtual void vfunc2();
        void func1();
        void func2();
    private:
        int m_data1, m_data2;
    };

![这里写图片描述][70 3]  
虚表是一个指针数组，其元素是虚函数的指针，每个元素对应一个虚函数的函数指针。需要指出的是，普通的函数即非虚函数，其调用并不需要经过虚表，所以虚表的元素并不包括普通函数的函数指针。 **虚表内的条目，即虚函数指针的赋值发生在编译器的编译阶段，也就是说在代码的编译阶段，虚表就可以构造出来了**。

**2、虚表指针**  
虚表是属于类的，而不是属于某个具体的对象，一个类只需要一个虚表即可。同一个类的所有对象都使用同一个虚表。  
![这里写图片描述][70 4]  
一个继承类的基类如果包含虚函数，那个这个继承类也有拥有自己的虚表，故这个继承类的对象也包含一个虚表指针，用来指向它的虚表。

**3、C++动态绑定过程详解**

class A {
    public:
        A() : m_data1(0), m_data2(0) {}
        virtual void vfunc1() { cout << "A::vfunc1" << endl; };
        virtual void vfunc2() { cout << "A::vfunc2" << endl; };
        void func1() { cout << "A::func1" << endl; };
        void func2() { cout << "A::func2" << endl; };
    private:
        int m_data1, m_data2;
    };
    
    class B : public A {
    public:
        B() : A(), m_data3(0) {}
        virtual void vfunc1() { cout << "B::vfunc1" << endl; };
        void func1() { cout << "B::func1" << endl; };
    private:
        int m_data3;
    };
    
    class C: public B{
    public:
        C() : B(), m_data1(0), m_data4(0) {}
        virtual void vfunc2() { cout << "C::vfunc2" << endl; };
        void func2() { cout << "C::func2" << endl; };
    private:
        int m_data1, m_data4;
    };

类A是基类，类B继承类A，类C又继承类B。类A，类B，类C，其对象模型如下图所示：  
![这里写图片描述][70 5]  
由于这三个类都有虚函数，故编译器为每个类都创建了一个虚表，即**类A的虚表**（A vtbl），类B的虚表（B vtbl），类C的虚表（C vtbl）。**类A，类B，类C的对象**都拥有一个虚表指针，\*\_\_vptr，用来指向自己所属类的虚表。  
类A包括两个虚函数，故A vtbl包含两个指针，分别指向A::vfunc1()和A::vfunc2()。  
类B继承于类A，故类B可以调用类A的函数，但由于类B重写了B::vfunc1()函数，故B vtbl的两个指针分别指向B::vfunc1()和A::vfunc2()。  
类C继承于类B，故类C可以调用类B的函数，但由于类C重写了C::vfunc2()函数，故C vtbl的两个指针分别指向B::vfunc1()（指向继承的最近的一个类的函数）和C::vfunc2()。  
上图看起来有点复杂，但是只要抓住“对象的虚表指针用来指向自己所属类的虚表，虚表中的指针会指向其继承的最近的一个类的虚函数”这个特点，便可以快速将这几个类的对象模型在自己的脑海中描绘出来。  
非虚函数的调用不用经过虚表，故不需要虚表中的指针指向这些函数。

**4、调用**

int main()
    {
        B bObject;
        A *p = &bObject;//执行动态绑定
        p->vfunc1();//B::vfunc1
    /* 程序在执行p->vfunc1()时，会发现p是个指针，且调用的函数是虚函数，接下来便会进行以下的步骤。 1、根据虚表指针p->__vptr来访问对象bObject对应的虚表。虽然指针p是基类A*类型， 但是*__vptr也是基类的一部分，所以可以通过p->__vptr可以访问到对象对应的虚表。 2、在虚表中查找所调用的函数对应的条目。由于虚表在编译阶段就可以构造出来了， 所以可以根据所调用的函数定位到虚表中的对应条目。对于p->vfunc1()的调用， B vtbl的第一项即是vfunc1对应的条目。 最后，根据虚表中找到的函数指针，调用函数。 从上图可以看到，B vtbl的第一项指向B::vfunc1()，所以 p->vfunc1()实质会调用B::vfunc1()函数。 */
    
        A aObject = (A)bObject;//将bObject截取A部分赋给aObject
        aObject.vfunc1();//静态绑定，A::vfunc1
    
        C cObject;
        p = &cObject;
        p->vfunc1();//动态绑定 B::vfunc1
        p->vfunc2();//静态绑定 C::func2
    
        cObject.A::func1();//静态绑定，强制指定调用的函数 A::vfunc1
        return 0;
    }

![这里写图片描述][70 6]

[https_blog.csdn.net_lihao21_article_details_50688337]: https://blog.csdn.net/lihao21/article/details/50688337
[70]: /images/20220528/193dadf3ccee430f8972c85d133ef7bd.png
[70 1]: /images/20220528/ecf7af631bac4388aa9f54bf6cdcbd7e.png
[70 2]: /images/20220528/6093361fb35e41d6841fae9e310f4c1c.png
[70 3]: /images/20220528/52c6bfcd05fa4bb48644cd93c05db95a.png
[70 4]: /images/20220528/5e5efba07b334c1c8e445dc2d3a933de.png
[70 5]: /images/20220528/be366f21993a40f7a135f1e0da7dc634.png
[70 6]: /images/20220528/d2b017a1a7544e1a9181ff0322fc6cc6.png