多态是一种泛型编程的思想，虚函数是其实现的手段（利用父类的指针指向子类的空间）。好了 ， 开始正文->

来一段基本代码：

#include <iostream>
using namespace std;
class CPeople
{
public:
    virtual void goHome()
    {
        cout << " Go Home" << endl;
    }
};
class Aonaufly : public CPeople
{
    void goHome()
    {
        cout << " Go Wuhan" << endl;
    }
};
int main()
{
    CPeople * people_1 = new Aonaufly;
    people_1->goHome();
    delete people_1;
    return 0;
}

运行结果：

解析 ：

① 虚函数的关键字是 ： virtual （定义格式 ： virtual void goHome()）

② 子类中也有一个goHome函数，因为在父类中goHome函数是个虚函数。所以子类中的goHome 与 父类中的goHome形成了重写。（虚函数形成重写 ， 普通函数形成覆盖）

③ CPeople * people_1 = new Aonaufly; 即用 利用父类的指针指向子类的空间。（不能申明为栈 ， 因为栈区队形没有指针概念）这种形式在C# / Java当中也很常见

④ 实际上在子类中的virtual可以省略不写，编译会自动加上

如果，在子类中不重写虚函数 ：

#include <iostream>
using namespace std;
class CPeople
{
public:
    virtual void goHome()
    {
        cout << " Go Home" << endl;
    }
};
class Aonaufly : public CPeople
{
};
int main()
{
    CPeople * people_1 = new Aonaufly;
    people_1->goHome();
    delete people_1;
    return 0;
}

结果：

解析：

① 因为子类没有重写父类虚函数goHome，所以调用父类的goHome

纯虚函数 -> 没有实现的函数

#include <iostream>
using namespace std;
class CPeople
{
public:
    virtual void goHome() = 0;
};
class Aonaufly : public CPeople
{
    virtual void goHome()
    {
        cout << " Go Wuhan" << endl;
    }
};
int main()
{
    CPeople * people_1 = new Aonaufly;
    people_1->goHome();
    delete people_1;
    return 0;
}

结果:

解析：

① 纯虚函数 virtual void goHome() = 0 。一个父类中都是纯虚函数，这个类就是接口类 ； 如果这个父类不全是纯函数那这个父类就是抽象类。

② 有纯虚函数的类 ， 不能被实例化 。只能通过继承 ， 在子类中实现（必须在子类中重写）

重点补充：

① 重写虚函数 ， 函数名称 /  函数参数列表 / 函数返回值类型必须是一样（绝大部分情况 ）

② 特殊情况：

#include <iostream>
using namespace std;
class CPeople
{
public:
    virtual CPeople& goHome()
    {
        cout << " Go Home" << endl;
        return (*this);
    }
};
class Aonaufly : public CPeople
{
    virtual Aonaufly& goHome()
    {
        cout << " Go Wuhan" << endl;
        return (*this);
    }
};
int main()
{
    CPeople * people_1 = new Aonaufly;
    people_1->goHome();
    delete people_1;
    return 0;
}

结果：

这是一个特殊的情况返回值不一样也会构成重写 ， 这个情况叫协变。

虚析构

为了时子类，父类中的机构函数都被调用，需要使用虚析构（不然 ， 只会调用父类的的 ）

#include <iostream>
using namespace std;
class CPeople
{
public:
    virtual CPeople& goHome()
    {
        cout << " Go Home" << endl;
        return (*this);
    }
    virtual ~CPeople()
    {
        cout << "Cpeople" << endl;
    }
};
class Aonaufly : public CPeople
{
    virtual Aonaufly& goHome()
    {
        cout << " Go Wuhan" << endl;
        return (*this);
    }
    ~Aonaufly()
    {
        cout << "Aonaufly" << endl;
    }
};
int main()
{
    CPeople * people_1 = new Aonaufly;
    //people_1->goHome();
    delete people_1;
    return 0;
}

结果：

关于虚继承

存在多继承的时候一定要使用虚继承

B,C继承于A 。 D继承B和C。若A与一个参数a，使用D.a就会造成歧义（从B，C继承了2个a）。那么B，C都要使用虚继承

class B : virtual public A

虚继承 只是继承使用权（相当于指针），并不复制A中的a

本文出自 “Better_Power_Wisdom” 博客，请务必保留此出处http://aonaufly.blog.51cto.com/3554853/1930677

C++ 继承（二）