初识C++之虚函数

1、什么是虚函数
　　在基类中用virtual关键字修饰，并在一个或多个派生类中被重新定义的成员函数，用法格式为：
　　virtual　函数返回类型　函数名（参数表）
　　 {
　　 　函数体
　　 }
　　 虚函数是实现多态性的关键，通过指向派生类的基类指针或引用，访问派生类中同名覆盖成员函数。
　　
看两个例子：
①没有定义基类的Fun函数为虚函数：

#define _CRT_SECURE_NO_WARNINGS 1#include <iostream>using namespace std;class Base{public:    void Fun()    {        cout << "Base::Fun()" << endl;    }private:    int data;};class Derived : public Base{public:    void Fun()    {        cout << "Derived::Fun()" << endl;    }private:    int data;};int main(){    Derived d;    Base* pb = &d;    pb->Fun();    return 0;}

可以看到此时基类指针虽然指向的是派生类，但仍然调用的是基类的Fun函数。

②定义了基类的Fun函数为虚函数：

#define _CRT_SECURE_NO_WARNINGS 1#include <iostream>using namespace std;class Base{public:    virtual void Fun()     //注意这儿加了关键字virtual    {        cout << "Base::Fun()" << endl;    }private:    int data;};class Derived : public Base{public:    void Fun()    {        cout << "Derived::Fun()" << endl;    }private:    int data;};int main(){    Derived d;    Base* pb = &d;    pb->Fun();    return 0;}

可以看到此时基类指针指向派生类后，其调用Fun函数时就是调用派生类的Fun函数了，从这儿也能看出虚函数是实现多态的关键。

2、虚函数的实现
①在基类中用virtual关键字修饰成员函数，使之成为一个虚函数，在派生类中重写该函数，使之完成新的功能。

②派生类中重写该虚函数时，要求重写的函数的函数名、参数列表、返回值都与基类虚函数相同，函数体根据需要选择是否重写。若不重写，则直接完成继承于基类。
PS：C++规定，当一个成员函数被定义为虚函数时，其派生类中的同名函数都自动变为虚函数，因此，派生类在重新定义该虚函数时，可加virtual关键字，也可以不加，但为了层次的清晰与代码的易读性，最好还是加上（那感觉前面说的都是废话）。

③定义一个基类的指针，使之指向同一类族中需要调用的函数所在类的对象。
PS：基类与派生类的赋值关系可以参考下面这篇博客中的第六条：
http://blog.csdn.net/ljx_5489464/article/details/51114534

④通过该指针调用虚函数，此时调用的就是指针指向的对象的同名函数了。

用一个实例来说明上述实现机制：

#define _CRT_SECURE_NO_WARNINGS 1#include <iostream>using namespace std;class Base{public:    virtual void Fun()     //加virtual关键字    {        cout << "Base::Fun()" << endl;    }private:    int data;};class Derived : public Base{public:    void Fun()    {        //重写Fun函数的函数体，当然，这儿不是必须要重写的        cout << "Derived::Fun()" << endl;    }private:    int data;};class Derived_Derived : public Derived{public:    void Fun()    {        //重写Fun函数的函数体，当然，这儿不是必须要重写的        cout << "Derived_Derived::Fun()" << endl;    }private:    int data;};int main(){    Derived_Derived d;    Derived* pb = &d;    pb->Fun();    return 0;}

我在Derived类中并没有在Fun函数前加virtual关键字，但pb指针调用的却是Derived_Derived类中的Fun函数，而非Derived类中的，这就说明了只要基类的成员函数被定义为虚函数时，派生类的同名函数就会变为虚函数。

注意：虚函数只能出现在类的继承层次中，只能定义类的成员函数为虚函数，不能定义类外的普通函数为虚函数：

#define _CRT_SECURE_NO_WARNINGS 1#include <iostream>using namespace std;virtual void Fun()     //注意这儿加了关键字virtual{    cout << "Base::Fun()" << endl;}int main(){    Fun();    return 0;}

以上代码会报错：

3、虚析构函数
　　析构函数执行时先调用派生类的析构函数，其次才调用基类的析构函数。如果析构函数不是虚函数，而程序执行时又要通过基类的指针去销毁派生类的动态对象（用new运算符创建的），那么用delete销毁对象时，只调用了基类的析构函数，未调用派生类的析构函数。这样会造成销毁对象不完全。

看例子：

#define _CRT_SECURE_NO_WARNINGS 1 #include <iostream> using namespace std; class Base { public: 　　Base()　　{ 　　　　cout << "Base()" << endl; 　　}　　　　~Base() 　　{　　　　cout << "~Base()" << endl; 　　} private: 　　int data; };class Derived: public Base {public: 　　Derived()　　{　　　　cout << "Derived()" << endl;　　}　　　　~Derived()　　{　　　　cout << "~Derived()" << endl;　　}private: 　　int data;}; int main(){ 　　Base *pb = new Derived;　　delete pb; 　　return 0; }

可以看到，确实是只调用了基类的析构函数，派生类的析构函数并没有被调用。

当我把基类的析构函数改成这样：

virtual ~Base() {　　cout << "~Base()" << endl;} 

再运行时，结果如下：

可以看到，此时不管是基类还是派生类的的析构函数都被调用了，为什么呢？
解析如下：
假设Derive类public继承自Base类，并且基类的析构函数没有定义为虚函数，有如下调用：
Base* pb = new Derive；
delete pb；
这时候，delete pb时，编译器会把pb当成Base的一个对象看待，因为pb是Base类型的，所以直接去调用基类的析构函数；
若将基类的析构函数写成virtual函数，那么基类和派生类的析构函数会分别存放在自己的虚表中，这时再执行delete pb时，会调用析构函数，但现在虚构函数是虚函数，所以会到虚表中去查找，而此时pb指向的刚好是一个派生类对象，所以通过虚表查找就找到了派生类的虚函数，从而调用派生类的析构函数。

4、纯虚函数
①定义：
　　纯虚函数是在基类中声明的虚函数，它在基类中没有定义，即没有函数体，但要求任何派生类都要实现自己的函数体。在基类中实现纯虚函数的方法是在函数原型后加“=0;“。
virtual void funtion()=0 ;

②引入原因 ：
　　为了方便使用多态特性，我们常常需要在基类中定义虚拟函数。 但在很多情况下，基类本身生成对象是不合情理的。例如，动物作为一个基类可以派生出老虎、孔雀等子类，但动物本身生成对象明显不合常理。 为了解决上述问题，引入了纯虚函数的概念，将函数定义为纯虚函数，则编译器要求在派生类中必须予以重写以实现多态性。这样就很好地解决了上述两个问题。

③作用：
　　纯虚函数的作用是在基类中为其派生类保留一个函数的名字，以便派生类根据需要对其进行实现，从而实现多态性。

④抽象类
　　不用来定义对象，只是作为一种基本类型用作继承的类，称为抽象类，由于抽象类通常作为基类，所以也称为抽象基类。包含纯虚函数的类就是抽象类，它不能生成对象。

注意：
①纯虚函数没有函数体；
②纯虚函数声明形式最后的“=0;”并不是返回值是0，它只是起一个形式上的作用，告诉编译器这是虚函数；
③虚函数的声明形式是一个语句，最后要加上“;”。
④纯虚函数只有声明，没有函数体，所以它不具有函数功能，因此不能被调用，可以称其为“徒有其表”。
⑤如果一个类中声明了虚函数，且在其派生类中没有被实现，那么在派生类中它仍为纯虚函数。

最后用一个实例来剖析：

class Animal{public:    virtual void Sleep() = 0;   //这里声明Sleep为纯虚函数public:    char sex[5];    int age;};class Person: public Animal{public:    virtual void Sleep()    {        cout << "Person lying down to sleep!" << endl;    }public:    char notionality[20];   //国籍    char name[10];};class Horse: public Animal{public:    virtual void Sleep()    {        cout << "Horse sleep standing up!" << endl;    }public:    char rase[20];          //种族};int main(){    Animal a;    return 0;}

此时用含有纯虚函数Sleep的抽象类Animal来创建对象时，会报错。

我把主函数改为调用抽象类Animal中的Sleep函数：

int main(){    Animal::Sleep();    return 0;}

调用一个纯虚函数，会报错。

我把Person修改了，去掉它对Sleep函数的实现：

class Person: public Animal{public:    char notionality[20];   //国籍    char name[10];};

此时Person类中没有对Sleep函数进行实现，因此，Person类中的Sleep函数仍为虚函数，会报错。