学习继承和虚析构函数

练习代码，该说的都在代码和注释里：

#include <string>

class BaseClass 
{
private:
    int pri;
protected:
    int pro;
public:
    int pub;

    BaseClass()
    {
        printf("调用父类的构造函数！
");
        to_string();
    }

    // 将析构函数设置为虚函数，以便在应用多态特征的时候，能够调用子类的析构函数释放子类动态申请的空间
    virtual ~BaseClass()    
    {
        printf("调用父类的析构函数！
");
    }
    virtual void to_string()
    {
        printf("调用父类的to_string：我是父类！
");
    }
    void do_something()
    {
        printf("我什么也没干！
");
    }
};

class DerivedClassPub : public BaseClass
{
private:
    char* name;
public:
    DerivedClassPub()
    {
        printf("调用子类的构造函数！
");
        pub = 1;    // 还是public
        pro = 1;    // 还是protected
//        pri = 1; 非法，不可访问
        const char* str = "小强";
        name = new char[strlen(str)+1];
        strcpy(name, str);
        to_string();
    }
    ~DerivedClassPub()
    {
        printf("调用子类的析构函数！
");

        // 如果父类的析构函数不是虚函数，在应用多态特性时：如使用父类的指针或者引用指向子类时，子类的析构函数不会被调用，动态申请的空间无法被释放
        delete name;
        name = NULL;
    }
    void to_string()
    {
        printf("调用子类的to_string：我是子类！我的名字是：%s
", name);
    }
    void do_something()
    {
        printf("我在跑步！
");
    }
};

class DerivedClassPro : protected BaseClass
{
public:
    DerivedClassPro()
    {
        pub = 1;    // 变成protected
        pro = 1;    // 还是protected
//        pri = 1; 非法，不可访问
    }
    ~DerivedClassPro(){}
};

class DerivedClassPri : private BaseClass
{
public:
    DerivedClassPri()
    {
        pub = 1;    // 变成private
        pro = 1;    // 变成private
//        pri = 1; 非法，不可访问
    }
    ~DerivedClassPri(){}
};

class AnotherBaseClass
{
public:
    AnotherBaseClass()
    {
        printf("调用父类的构造函数！
");
    }
    ~AnotherBaseClass()
    {
        printf("调用父类的析构函数！
");
    }
};
class AnotherDerivedClass : public AnotherBaseClass
{
public:
    AnotherDerivedClass()
    {
        printf("调用子类的构造函数！
");
    }
    ~AnotherDerivedClass()
    {
        printf("调用子类的析构函数！
");
    }
};

int main()
{
    // 构造的时候，先调用父类的构造函数，若其中调用了任何虚函数和非虚函数，均是父类的函数，因为此时还没构造出子类的那部分，换句话说，现在才构造了一半
    BaseClass* base = new DerivedClassPub();

    // 因为析构函数是虚函数，所以调用子类的析构函数，之后再调用父类的析构函数，为什么？
    printf(">> 当析构函数是虚函数时：
");
    delete base;
    printf("<< 结束！


");
    base = NULL;

    AnotherBaseClass* another_base = new AnotherDerivedClass();
    printf(">> 当析构函数不是虚函数时：
");
    delete another_base;
    printf("<< 结束！


");
    another_base = NULL;

    DerivedClassPub* d = new DerivedClassPub();
    printf(">> 当析构函数是虚函数时：
");
    delete d;
    printf("<< 结束！


");
    d = NULL;

    AnotherDerivedClass* ad = new AnotherDerivedClass();
    printf(">> 当析构函数不是虚函数时：
");
    delete ad;
    printf("<< 结束！


");
    ad = NULL;

    return 0;
}

输出结果：

调用父类的构造函数！
调用父类的to_string：我是父类！
调用子类的构造函数！
调用子类的to_string：我是子类！我的名字是：小强
>> 当析构函数是虚函数时：
调用子类的析构函数！
调用父类的析构函数！
<< 结束！


调用父类的构造函数！
调用子类的构造函数！
>> 当析构函数不是虚函数时：
调用父类的析构函数！
<< 结束！


调用父类的构造函数！
调用父类的to_string：我是父类！
调用子类的构造函数！
调用子类的to_string：我是子类！我的名字是：小强
>> 当析构函数是虚函数时：
调用子类的析构函数！
调用父类的析构函数！
<< 结束！


调用父类的构造函数！
调用子类的构造函数！
>> 当析构函数不是虚函数时：
调用子类的析构函数！
调用父类的析构函数！
<< 结束！


请按任意键继续. . .