初学者刚接触C++语言中的 virtual 函数（虚函数）时，常常会感觉到迷惑，比如，书上说虚函数定义在基类中，其他继承此基类的派生类都可以重写该虚函数，因此虚函数是C++语言多态特性中非常重要的概念。但是派生类也可以重写基类中的其他的常规函数（非虚函数）呀，那为什么还要引入虚函数这样看起来很复杂的概念呢？

“猫吃老鼠”

本文不打算从理论上探讨C++语言引入虚函数的原因，那样太枯燥乏味了，我们先来看一个例子，直观上感觉下常规（非虚）函数在面向对象编程中的局限性，请看：

class Animal
{
public:
    void eat() {
         std::cout << "I'm eating generic food." 
    }
};

class Cat : public Animal
{
public:
    void eat() { 
    std::cout << "I'm eating a rat.";
    }
};

上面这段C++语言代码定义了Animal（动物）和Cat（猫）两个类，其中Cat继承了Animal（猫显然是动物），我们可以在 main() 函数中使用这两个类：

Animal *animal = new Animal;
Cat *cat = new Cat;

animal->eat(); // 输出： "I'm eating generic food."
cat->eat();    // 输出： "I'm eating a rat."

到这里一切都挺好的，动物吃食物，猫吃老鼠，即使不使用virtual关键字定义虚函数也完全没有问题。

现在我们稍稍修改下这段C++语言代码，引入另外一个函数func()（暂时不考虑实用性，仅做示例），它的代码如下，请看：

void func(Animal *xyz)
{
    xyz->eat();
}

现在我们在 main() 函数中调用 func() 函数，相关的C++语言代码示例如下，请看：

Animal *animal = new Animal;
Cat *cat = new Cat;

func(animal); // 输出： "I'm eating generic food."
func(cat);    // 输出： "I'm eating generic food."

出问题了~请注意第二个 func() 函数调用，我们传递了一个Cat对象指针给它，但是输出的却不是“I'm eating a rat.”！仔细观察一下，发现 func() 函数的参数类型是Animal *xyz，那么为了让 func() 函数也能输出“I'm eating a rat.”，只能重载 func() 函数了：

void func(Animal *xyz)
{
    xyz->eat();
}
void func(Cat *xyz)
{
    xyz->eat();
}

现在 func() 函数能够根据输入参数类型的不同，输出不同的内容了。可是问题来了，Animal（动物）是一个基类，它能派生出的动物远远不止Cat（猫）一种，若是派生出许多派生类，每个派生类都重载一遍 func() 函数，是不是太麻烦了？

神奇的虚函数

在C++语言中，重写基类中的常规（非虚）函数当然是可以的，但是从上面的例子可以看出，重写常规函数实现多态有时会带来非常麻烦的问题，要避免这样的问题可以使用 virtual function（虚函数）。现在，我们在 Animal 基类的 eat() 成员函数前加上virtual关键字：

class Animal
{
public:
    virtual void eat() {
         std::cout << "I'm eating generic food." 
    }
};

class Cat : public Animal
{
public:
    void eat() { 
    std::cout << "I'm eating a rat.";
    }
};

此时无需重载 func() 函数，仅保留一份 func() 函数：

void func(Animal *xyz)
{
    xyz->eat();
}

再执行下面的C++语言代码，输出就不同了：

func(animal); // 输出： "I'm eating generic food."
func(cat);    // 输出： "I'm eating a rat."

看来，C++语言中的虚函数的确有些过人之处，有必要好好了解一下它。

事实上，每一个C++程序员都不可能避开虚函数的，就像每一个C语言程序员都不可能避开指针一样。

再总结下“什么是虚函数”

理论是少不了的，它可以加深和尽可能全面的帮助我们理解概念。基类中的虚函数允许派生类重写功能，编译器会保证派生类对象使用的是自己重写的功能，即使对象是通过基类指针访问的，例如前文中的 func(Animal *xyz) 函数，func(cat) 输出的实际上是 Cat 类重写的功能。这是一个非常有用的特性，调用者甚至都不需要知道 Cat 等派生类的实现，因为只需使用基类 Animal 指针就能够轻易的调用所有派生类的重写功能。

基类的虚函数可以完全被重写，也可以部分的被重写，所谓的“部分被重写”，其实就是派生类在重写基类虚函数时，也可以调用基类虚函数的功能。

虚函数和常规函数被调用时有什么不同？

常规的非虚函数是静态解析的，即在编译时即可根据指针指向的对象确定是否被调用，例如文章开头的例子，如果 eat() 函数是非虚函数：

// eat() 函数不是虚函数

Animal *animal = new Animal;
Cat *cat = new Cat;

animal->eat(); // 输出： "I'm eating generic food."
cat->eat();    // 输出： "I'm eating a rat."

此时编译器在编译时就能确定 animal->eat() 调用的是 Animal::eat() 函数，cat->eat() 调用的是 Cat::eat() 函数。在 func(Animal *xyz) 函数中，因为其形参是 Animal *指针类型，所以即使传入的是 cat 对象指针，在 func() 函数内部也会被强制转换为Animal *指针，因此 func(cat) 调用的仍然是 Animal::eat() 函数。

而虚函数就不同了，它是动态解析的，也即在程序被编译后，运行时才根据对象的类型，而不是指向对象的指针类型决定其是否被调用，这就是说为的“动态绑定”。

关于“动态绑定”，我们在之后几节中再做详细讨论，这里先留个印象。

在C++语言中，如果某个类有虚函数，那么大多数编译器都会自动的为其对象维护一个隐藏的“虚指针（virtul-pointer）”，虚指针指向一个全局“虚表（virtual-table）”，虚表中存放若干函数指针，这些函数指针指向类中的虚函数。请看下面这段C++语言代码：

class A {
public:
    virtual void vfoo1();
    virtual void vfoo2();
    void foo1();
    void foo2();
private:
    int prv_i1, prv_i2;
};

显然，类 A 有两个常规函数以及两个 int 型的成员变量，此外，它还有两个虚函数，因此编译器会创建一个虚表，虚表中存放的是函数指针，它们分别指向类 A 的虚函数，如下图所示：

这里应注意，虚表是属于类的，而不是对象的，也就是说，即使有成千上万个 A 对象，虚表也仅有一个，这些对象共用一个类虚表。编译器会自动的为每个对象创建一个隐藏的“虚指针”__vptr，它指向类 A 的虚表，如下图所示：

C++语言这样实现虚函数机制的空间开销是微乎其微的，事实上，每一个对象只需要一个额外的“虚指针”__vptr就能够调用类的虚函数。同样的，时间开销也很小：相比于常规函数的调用，虚函数的调用只不过多出了额外的两个步骤：

1. 获取虚表指针，得到虚表
2. 从虚表中取出虚函数的地址

读者应注意，这里的讨论为了突出主题，理想化了一些情况。

为什么类成员函数默认都不是虚函数？

既然虚函数这么好用，那为什么C++语言不把类的成员函数默认定义为虚函数呢？

其实仔细考虑一下，虚函数的“好用”主要体现在定义在基类中实现多态上，但并不是所有的类都需要被设计为基类，一昧的使用虚函数可能会造成语义上的歧义，隐藏程序员的设计。仅将需要被继承的基类中需要被重写的函数定义为虚函数，要比将所有函数定义为虚函数清晰多了。

此外，经过前面的讨论，我们也知道虚函数的效率实际上是没有常规函数高的，同样的功能中，仅从被调用过程来看，它的时间开销和空间开销都比常规函数高，每个对象还需要额外的虚指针索引虚表。

小结

本文主要讨论了C++语言中虚函数的基本使用，以及其在C++中的基本设计，并未太多深入，因此还有许多问题没有说清楚，比如虚函数在派生类中是如何被继承的？究竟什么是“动态绑定”？什么是“纯虚函数”？，等等。当然了，一篇文章也不可能将虚函数完全说清楚，只希望本文能够对读者有所帮助，更多问题在接下来的文章中会讨论，敬请关注。

欢迎在评论区一起讨论，质疑。文章都是手打原创，每天最浅显的介绍C语言、linux等嵌入式开发，喜欢我的文章就关注一波吧，可以看到最新更新和之前的文章哦。

未经许可，禁止转载。

代码看着不方便的话，可以点击文章末尾的“了解更多”。