C++多态实现（通过虚继承、虚函数实现）及虚析构函数，多重继承和多级继承，纯虚函数和抽象类的使用实例

C++多态实现（通过虚继承、虚函数实现）及虚析构函数，多重继承和多级继承，纯虚函数和抽象类的使用实例

代码可以直接copy运行：

继承关系：

类AbstractBase被类A继承，类A被类B和类C继承，类B和类C同时被类D继承。

#include <string>
#include <iostream>
using namespace std;

#define __MODE1
//#define __MODE2
namespace NM_ENUM {
    enum Type{T_A, T_B, T_C, T_D};
}

class AbstractBase{// 抽象类
public:
    AbstractBase(){}
    virtual ~AbstractBase(){}
    virtual void setType() = 0;// 纯虚函数（含有纯虚函数的类是抽象类，不能实例化对象）
    virtual void print() = 0;
    NM_ENUM::Type getType()
    {
        return m_eType;
    }
    NM_ENUM::Type           m_eType;
};

class A : public AbstractBase
{
public:
    A()
    {
        std::cout << "A" << std::endl;
    }
    ~A()// 虚析构函数，避免继承时子类未析构（有的编译器会提示段错误而终止，如MSVC）导致内存泄漏
    {
        std::cout << "~A" << std::endl;
    }
    void print()// 虚函数，实现多态
    {
        std::cout << "A print" << std::endl;
    }

    void setType()
    {
        m_eType = NM_ENUM::T_A;
    }

    string              m_a;
};

class B: virtual public A// 虚继承，解决D对B、C多继承时的冲突
{
public:
    B()
    {
        std::cout << "B" << std::endl;
    }
    ~B()
    {
        std::cout << "~B" << std::endl;
    }
    void print()
    {
        std::cout << "B print" << std::endl;
    }

    void setType()
    {
        m_eType = NM_ENUM::T_B;
    }

    string              m_b;
};

class C: virtual public A
{
public:
    C()
    {
        std::cout << "C" << std::endl;
    }
    ~C()
    {
        std::cout << "~C" << std::endl;
    }
    void print()
    {
        std::cout << "C print" << std::endl;
    }

    void setType()
    {
        m_eType = NM_ENUM::T_C;
    }

    string              m_c;
};

class D: public B, public C// 多重继承+多级继承
{
public:
    D()
    {
        std::cout << "D" << std::endl;
    }
    ~D()
    {
        std::cout << "~D" << std::endl;
    }
    void print()
    {
        std::cout << "D print" << std::endl;
    }

    void setType()
    {
        m_eType = NM_ENUM::T_D;
    }

    string              m_d;
};

void transferParameter(AbstractBase *p)
{
    p->print();
}

int main()
{
#ifdef __MODE1
    std::cout << "--------------MODE1构造--------------" << std::endl;
    A *pA, *pB, *pC, *pD;
    std::cout << "-----A-----" << std::endl;
    A *p = new A;
    p->print();
    pA = p;
    std::cout << "-----B-----" << std::endl;
    p = new B;// 多态的应用（父类的指针指向子类的对象）
    p->print();
    pB = p;
    std::cout << "-----C-----" << std::endl;
    p = new C;
    p->print();
    pC = p;
    std::cout << "-----D-----" << std::endl;
    p = new D;
    p->print();
    pD = p;

    transferParameter(p);// 测试参数传递

    dynamic_cast<D *>(p)->m_d = "this is D menber data";
    std::cout << "data:" << dynamic_cast<D *>(p)->m_d << std::endl;

    std::cout << "--------------MODE1析构--------------" << std::endl;
    p = NULL;
    std::cout << "-----~A-----" << std::endl;
    delete pA;
    pA = NULL;
    std::cout << "-----~B-----" << std::endl;
    delete pB;
    pB = NULL;
    std::cout << "-----~C-----" << std::endl;
    delete pC;
    pC = NULL;
    std::cout << "-----~D-----" << std::endl;
    delete pD;
    pD = NULL;
#endif

#ifdef __MODE2
    std::cout << "--------------MODE2构造--------------" << std::endl;
    std::cout << "-----A-----" << std::endl;
    A *p1 = new A;
    p1->print();
    std::cout << "-----B-----" << std::endl;
    A *p2 = new B;
    p2->print();
    std::cout << "-----C-----" << std::endl;
    A *p3 = new C;
    p3->print();
    std::cout << "-----D-----" << std::endl;
    A *p4 = new D;
    p4->print();
    std::cout << "--------------MODE2析构--------------" << std::endl;
    std::cout << "-----~A-----" << std::endl;
    delete p1;
    p1 = NULL;
    std::cout << "-----~B-----" << std::endl;
    delete p2;
    p2 = NULL;
    std::cout << "-----~C-----" << std::endl;
    delete p3;
    p3 = NULL;
    std::cout << "-----~D-----" << std::endl;
    delete p4;
    p4 = NULL;
#endif
    return 0;
}

运行结果：

使用条件编译__MODE1:

使用条件编译__MODE2: