初识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函数仍为虚函数。会报错。