简介

本章节会介绍在C++中虚函数及纯虚函数的主要作用，C++也是通过虚函数实现动态绑定，本小节不会去讲述动态绑定内部实现原理，具体可以参考[C++动态绑定原理].

结构图

• 虚函数
  • 成员函数(member function)为虚函数(virtual function)
  • 析构函数为虚函数
• 纯虚函数
  • 成员函数为纯虚函数(pure virtual function)
  • 析构函数为纯虚函数

虚函数

• 成员函数为虚函数

  在开始虚函数之前，先看一段代码分析其中的问题。

#include <iostream>
class Animal {
public:
    Animal() {}
    ~Animal(){}
    void run(void) {
        std::cout << "Animal run..." << std::endl;
    }
};

class Cat : public Animal{
public:
    Cat() : Animal(){}
    void run(void) {
        std::cout << "Cat run..." << std::endl;
    }
};
int main(int argc,char** argv)
{
    Animal *animal = new Cat; //创建Cat对象，然后执行向上类型转换
    animal->run();
    return 0;
}
/*输出结果*/
//Animal run...

在以上代码中，animal所指向的为Cat对象，但是当调 用run函数的时候，打印的值是"Animal run...",并不是"Cat run...",这是因为当编译器看到"animal"的指针类型是"Animal"时，自然而然的就会调用Animal::run(),在编译时期，就已经确定所要调用的具体函数，这也就是所说的静态绑定。

在开始后面讲解之前，需要先记住两点知识：
1. 声明一个虚函数需要使用关键字:virtual
2. 当基类(或称为父类)中的某函数A()被声明为虚函数之后，在继生类(或称为子类)中重载的A(),即不使用virtual修饰，也是虚函数

现在对上面的代码进行修改，将void Animal::run()修改为虚函数，即改为virtual void Animal::run(),观察修改后的运行情况。

#include <iostream>
class Animal {
public:
    Animal() {}
    ~Animal() {}
    virtual void run(void) {  //!!!!!!!!!!注意此处的修改
        std::cout << "Animal run..." << std::endl;
    }
};

class Cat : public Animal {
public:
    Cat() : Animal() {}
    void run(void) {
        std::cout << "Cat run..." << std::endl;
    }
};
int main(int argc, char** argv)
{
    Animal *animal = new Cat; //创建Cat对象，然后执行向上类型转换
    animal->run();
    return 0;
}
//输出结果：
//Cat run...

当Animal::run()为虚函数时，输出结果为Cat run...,这也就是虚函数的作用，此时在程序运行时去决定调用哪一个run()函数，这也就是动态绑定。在这里animal实际上指向的是Cat对象，所以调用的是Cat::run()。

• 析构函数为虚函数

  当基类中包含虚成员函数的时候，一般会把析构函数
  也定义为虚析构函数

  虚析构函数和虚成员函数在函数定义上是一样的，只需要添加virtual关键字就可以了，这里主要介绍定义虚析构函数的原因：

  1. 为了通过基类指针正确释放该指针所指向的对象(该指针可能指向一个子类)

  通过实例了解一下：

#include <iostream>
class Base1 {
public:
    virtual void print(void) {
        std::cout << "Base1 print" << std::endl;
    }
    ~Base1(){
        std::cout << "Base1's destructor" << std::endl;
    }
};
class Derived1 : public Base1
{
public:
    Derived1(int n) {
        p = new char[n];
    }
    void print(void) {
        std::cout << "Derived1 print" << std::endl;
    }
    ~Derived1() {
        delete[]p;
        std::cout << "Derived1's destructor" << std::endl;
    }
private:
    char *p;
};

class Base2 {
public:
    virtual void print(void) {
        std::cout << "Base2 print" << std::endl;
    }
    virtual ~Base2() {
        std::cout << "Base2's destructor" << std::endl;
    }
};
class Derived2 : public Base2
{
public:
    Derived2(int n) {
        p = new char[n];
    }
    void print(void) {
        std::cout << "Derived2 print" << std::endl;
    }
    ~Derived2() {
        delete[]p;
        std::cout << "Derived2's destructor" << std::endl;
    }
private:
    char *p;
};
int main(int argc, char** argv)
{
    std::cout << "Base1 test: \n";
    Base1 *base1 = new Derived1(5);
    base1->print();
    delete base1;
    std::cout << "\n\nBase2 test: \n";
    Base2 *base2 = new Derived2(5);
    base2->print();
    delete base2;
    return 0;
}
//输出结果：
Base1 test:
Derived1 print
Base1's destructor


Base2 test:
Derived2 print
Derived2's destructor
Base2's destructor

base1实际指向Derived1对象，在Derived中通过new在堆上创建了5个char,但是当执行delete base1;的时候，只调用了Base1::~Base1()，但却没有调用Derived1::~Derived1(),最终导致这5个char无法释放，而导致内存泄漏。

当把Base2的析构函数声明为虚函数的时候，调用delete base2,会先调用Derived2::~Derived2(),然后再调用Base2::~Base2(),所有内存成功释放。

纯虚函数

TODO