[TOC]

父类析构函数和普通函数声明为纯虚或虚函数时调用子类方法

例子如代码所示

1. B 是 A 子类
2. A *a = new B()

注意

1. 父类的普通成员函数是纯虚函数，父类可以也可以不实现此方法，只是表示子类必须实现这个方法，父类指针只会调用子类的这个方法实现，不会调用父类的。

2. 父类的普通成员函数是虚函数，父类必须实现此方法，同时表示子类可以也可以不实现这个方法，如果子类实现了此方法，父类指针会调用子类的这个方法实现；如果子类没实现，父类指针会调用父类自身的方法实现。

3. 父类的普通成员函数不是虚函数，父类实现了，无论指针是否重写了此方法，父类指针只会调用自身的方法实现。

4. 父类的析构函数是纯虚函数，父类必须实现此析构函数，子类可实现可不实现，因为不实现系统会默认生成一个，delete a 时，先执行子类的析构函数，再执行父类自身的析构函数。

5. 父类的析构函数是虚函数，父类必须实现此析构函数，子类可实现可不实现，因为不实现系统会默认生成一个，delete a 时，会先执行子类的析构函数，再执行父类自身的析构函数。(可见纯虚析构函数和虚析构函数一样)

6. 父类的析构函数不是虚函数，父类必须实现此析构函数，delete a 时，只会执行父类自身的析构函数。

#include <iostream>
using namespace std;

class A
{
public:
    A(int size) : m_a_size(size) { m_a = new int[size]; }
    virtual ~A() = 0;
    virtual void F1() = 0;
    virtual void F2();
    void F3() { cout << "A F3\n" << endl; }
    void F4() { cout << "A F4\n" << endl; }

private:
    int *m_a;
    int m_a_size;
};

A::~A()
{
    cout << "delete m_a" << endl;
    delete[] m_a;
}

void A::F1() { cout << "A F1\n" << endl; }

void A::F2() { cout << "A F2\n" << endl; }

class B : public A
{
public:
    B(int a_size, int b_size) : A(a_size), m_b_size(b_size)
    {
        m_b = new int[b_size];
    }
    ~B();
    void F1() { cout << "B F1\n" << endl; }
    void F3() { cout << "B F3\n" << endl; }

private:
    int *m_b;
    int m_b_size;
};

B::~B()
{
    cout << "delete m_b" << endl;
    delete[] m_b;
}

int main()
{
    // 父类析构函数是否虚函数区别
    A *a1 = new B(5, 10);
    delete a1;

    // 子类成员函数是否重写父类成员方法
    A *a2 = new B(6, 12);
    a2->F1();
    a2->F2();
    a2->F3();
    a2->F4();
    return 0;
}