简介

虚函数是C++中用于实现多态(polymorphism)的机制。核心理念就是通过基类访问派生类的函数。
例如下面的两个类：

class Base {
    public: 
        virtual void func() { std::cout << "Base::func() is called" << std::endl;};
};
class Derive : public Base {
    public: 
        virtual void func() { std::cout << "Derive::func() is called" << std::endl;};
};

使用时：

    Base* base = new Derive();
    base->func();  //base虽然是指向Base的指针，但是被调用的函数func()是A的函数

此处输出的内容为：Derive::func() is called。这只是一个简单的虚函数的例子，从这里能大概看出虚函数的一些样子。此处也需要知道一点，创建一个基类的实例可以从派生类中new创建出来，但是派生类的实例不能来源于new一个基类，这也是面向对象的一些原则。另外一个方面，虚函数只能借助于指针或者引用来达到多态的效果，例如下面这样的代码，虽然都是虚函数，但它却不是多态：

void f(void) {
  Base b;
  b.func(); // 此处输出："Base::func() is called"
}

多态

1.多态有什么用

C++中的虚函数的作用主要是实现了多态的机制。关于多态，简而言之就是用父类型的指针指向其子类的实例，然后通过父类的指针调用实际子类的成员函数。这种技术可以让父类的指针有“多种形态”，这是一种泛型技术。所谓泛型技术，说白了就是试图使用不变的代码来实现可变的算法。比如：模板技术，RTTI技术，虚函数技术，要么是试图做到在编译时决议，要么试图做到运行时决议。例如：

void f(Base* b)
{
    b->func();  // 被调用的是Derive::func() 还是Base::func()?
}

因为func()是一个虚函数，只通过这一段代码是无法判断调用的是哪一个类的函数。从面向对象的得知，函数传入的实例可能是Base基类，也可能是派生类Derive，所以需要在编译时是无法确定此函数的调用，这种同一代码可以产生不同效果的特点，被称为“多态”。

动态联编

虚函数实际上是如何被编译器处理的呢？Lippman在深度探索C++对象模型中的不同章节讲到了几种方式，这里把“标准的”方式简单介绍一下。
我所说的“标准”方式，也就是所谓的VTABLE（虚函数表）机制。编译器发现一个类中有被声明为virtual的函数，就会为其创建一个虚函数表，也就是 VTABLE。VTABLE实际上是一个函数指针的数组，每个虚函数的指针占用这个数组的一个slot。一个类只有一个VTABLE，不管它有多少个实例。派生 类有自己的VTABLE，但是派生类的VTABLE与基类的VTABLE有相同的函数排列顺序，同名的虚函数被放在两个数组的相同位置上。后面将会详细讲虚函数表。

overload和override

• overload(重载)
  overload是指一个与已有函数同名但是参数表不同的函数。例如一个函数即可以接受整型数作为参数，也可以接受浮点数作为参数，还可以接受string等，这样让编译器来判断使用哪一个函数来达到效率最优。
• override(覆盖)
  虚函数总是在派生类中被改写，这种改写被称为“override”，翻译成覆盖貌似比较多。override是指派生类重写基类的虚函数，就象我们前面Derive类中重写了Base类中的func()函数。重写的函数必须有一致的参数表和返回值，C++标准允许 返回值不同的情况，但是很少编译器支持这个feature。目前我也没有使用过这种特性，这会让我的代码变的混乱，建议大家最好也不要用到这个特性。

虚函数语法

virtual关键字

class Base
{
  public:
    virtual void func();
};
class Derive: public Base
{
  public:
    void func();    // 没有virtual关键字
};
class Derive: public Derive  // 从Derive继承，不是从Base继承
{
  public:
    void func();    // 也没有virtual关键字
};

例如上面的代码，Derive::func()是虚函数，Derive::func()也同样是虚函数。基类声明的虚函数，在派生类中也是虚函数，不管是否使用virtual关键字。但是通常为了代码简洁易懂，最好在派生类中也添加上virtual关键字，那么一眼就知道是虚函数。

纯虚函数

class Base
{
  public:
    virtual void func()=0;   // =0标志一个虚函数为纯虚函数
};

一个函数声明为纯虚后，纯虚函数的意思是：我是一个抽象类,不可以把我实例化。纯虚函数用来规范派生类的行为，实际上就是所谓的“接口”，在java中就是interface。它告诉使用者，我的派生类都会有这个函数，并且需要实现它，否则就是一个指向为空的指针，没有可以执行的函数。事实是怎样的呢，如下：

class Derive : public Base {
  public: 
};

int main() {
  Derive* derive = new Derive();
  derive->func();
}

此代码的在gcc version 6.5.0 (MacPorts gcc6 6.5.0_1)下编译，事实结果如下：

1563933633906.jpg

编译都没有通过，所以虚函数是必须要实现。

虚析构函数

首先我们看如下的代码：

class Base {
  public:
    Base(){};
    ~Base(){std::cout << "Base::~Base() is called!" << std::endl;}
};
class Derive : public Base {
  public:
    Derive(){};
    ~Derive(){std::cout << "Derive::~Derive() is called!" << std::endl;}
};

int main(void) {
    Base* base = new Derive;
    delete base;
    return 0;
}

结果可能跟你想的不一样，只有Base类的析钩函数被调用了。

1564019256607.jpg

所以想要达到你想要的效果，需要把基类的析构函数加上关键字virtual。结果下图：

image.png

所以我们在定义析构函数时，需要给他加上virtual关键字，一般情况下不需要定义成纯虚函数。只有在希望将一个类变成抽象类（不能实例化的类），而这个类又没有合适的函数可以被纯虚化的时候，可以使用纯虚的析构函数。另外一点如果上面的代码，Base类中虚函数甚至都没有定义，main函数中delete base时，什么都不会发生，也不会调用派生类A的析构函数。

虚函数表

虚函数表

使用C++的人都应该知道虚函数Virtual Function，它是通过一张虚函数表Virtual Table来实现，简称为V-Table，前文所说的标准方式，其他方式不讨论。在这个表中，主是要一个类的虚函数的地址表，这张表解决了继承、覆盖的问题，保证其容真实反应实际类中的函数。这样，在有虚函数的类的实例中这个表被分配在了这个实例的内存中。所以，当我们用父类的指针来操作一个子类的时候，这张虚函数表就显得非常重要了，它就像一个地图一样，指明了实际所应该调用的函数。
这里我们着重看一下这张虚函数表。C++的编译器应该是保证虚函数表的指针存在于对象实例中最前面的位置（这是为了保证取到虚函数表的有最高的性能，如果有多层继承或是多重继承的情况下）。 这意味着我们通过对象实例的地址得到这张虚函数表，然后就可以遍历其中函数指针，并调用相应的函数。如下代码通过实例地址来获取，编译环境(gcc version 6.5.0 (MacPorts gcc6 6.5.0_1)):

class Base {
  public:
    virtual void func1() { std::cout << "Base::func1" << std::endl; }
    virtual void func2() { std::cout << "Base::func2" << std::endl; }
    virtual void func3() { std::cout << "Base::func3" << std::endl; }
};

typedef void (*Func)(void);
int main(int argc, char** argv){
  Base b;
  Func func = nullptr; //c++11的空指针
  std::cout << "vtable pointer address："<< (long*)(&b) << std::endl;
  std::cout << "vtable address："<< *(long*)(&b) << std::endl;
  std::cout << "vtable - first function pointer address："<< (long*)*(long*)(&b) << std::endl;
  std::cout << "vtable - first function address："<< *(long*)*(long*)(&b) << std::endl;
  func = (Func)*((long*)*(long*)(&b));  // Invoke the first virtual function
  func();
  return 0;
}

int main(int argc, char** argv) {
  Base b;
  Func func1 = nullptr;
  Func func2 = nullptr;
  Func func3 = nullptr;
  func1 = (Func)*((long*)*(long*)(&b) + 0);
  func2 = (Func)*((long*)*(long*)(&b) + 1);
  func3 = (Func)*((long*)*(long*)(&b) + 2);
  func1();
  func2();
  func3();
}

上面两段代码的运行结果如下图，图1输出依次是虚函数表的指针地址，对指针地址取值后是虚函数表的地址，然后是第一个虚函数的指针地址，取值后为虚函数的地址。类型转化后，运行就知，指向的是第一个虚函数。通过后面对地址的增加可以取到第二个，第三个虚函数。虚函数是按照申明时的顺序排列，对地址按顺序加，就可以按顺序得到虚函数，如图2。

1.png

2.png

内存中的结构

如果看了上面还是有些不懂，下面画出大概的内存中的示例图来表示：

• 一般继承 - 无虚函数覆盖
  覆盖父类的虚函数是很显然的事情，不然，虚函数就变得毫无意义。如下的示意图：
  

  image.png
  
  在这个继承关系中，子类没有覆盖或者继承任何的父类函数，那么对于一个实例Derive d;，虚函数表示意如下：
  
  image.png
  
  我们可以看到下面两点：
  1. 虚函数按照其声明顺序放于表中。
  2. 父类的虚函数在子类的虚函数前面。
     
     

• 一般继承 - 有虚函数覆盖
  覆盖父类的虚函数是很显然的事情，不然，虚函数就变得毫无意义。子类中有虚函数重载了父类的虚函数：

  
  
  image.png

image.png

我们从表中可以看到下面两点：

1. 覆盖的f()函数被放到了虚表中原来父类虚函数的位置
2. 没有被覆盖的函数依旧
   
   

• 多重继承 - 无虚函数覆盖
  子类并没有覆盖父类的函数:

  
  
  image.png

image.png

我们可以看到下面两点：

1. 每个父类都有自己的虚表
2. 子类的成员函数被放到了第一个父类的表中（第一个父类是按照声明顺序来判断）

这样做就是为了解决不同的父类类型的指针指向同一个子类实例，而能够调用到实际的函数。

• 多重继承 - 有虚函数覆盖
  虚函数覆盖的情况:

  
  
  image.png

image.png

int main(int argc, char ** argv) {
    Derive d;
    Base1 *b1 = &d;
    Base2 *b2 = &d;

    b1->f(); //Derive::f()
    b2->f(); //Derive::f()
 
    b1->g(); //Base1::g()
    b2->g(); //Base2::g()
}

安全性

我们知道，子类没有重载父类的虚函数是一件毫无意义的事情。因为多态也是要基于函数重载。任何妄图使用父类指针想调用子类中的未覆盖父类的成员函数的行为都会被编译器视为非法，所以，这样的程序根本无法编译通过。但在运行时，我们可以通过指针的方式访问虚函数表来达到违反C++语义的行为。如下代码：

class Base {
  public:
    virtual void func1() { std::cout << "Base::func1() is called!" << std::endl; }
    virtual void func2() { std::cout << "Base::func2() is called!" << std::endl; }
};
class Derive : public Base {
  public:
    virtual void func1() { std::cout << "Derive::func1() is called!" << std::endl; }
    virtual void func3() { std::cout << "Derive::func3() is called!" << std::endl; }
};

Base* b = new Derive();
b->func3(); //编译失败

Derive* d = new Derive();
d->func2(); //输出 Base::func2() is called!

Base* b = new Derive();
b->func1(); //输出 Derive::func1() is called!

第二种情况是访问non-public的虚函数。如果父类的虚函数是private或protected，但这些非public的虚函数同样会存在于虚函数表中，所以，我们同样可以使用访问虚函数表的方式来访问这些non-public的虚函数，这很容易做到。如下：

class Base {
  private:
    virtual void func1() { std::cout << "Base::func1() is called!" << std::endl; }
};
class Derive : public Base {
};
typedef void (*Func)(void);
int main(int argc, char** argv) {
    Derive d;
    Func  func = (Func)*((long*)*(long*)(&d)+0);
    func();
    return 0;
}

image.png