期末考试 编程题＃10：输出指定结果二（Coursera 程序设计与算法 专项课程3 C++程序设计 郭炜、刘家瑛；虚函数继承）

编程题＃10：输出指定结果二

来源: 北京大学在线程序评测系统POJ (Coursera声明：在POJ上完成的习题将不会计入Coursera的最后成绩。)

总时间限制: 1000ms 内存限制: 1024kB

描述
通过填空使得程序输出的结果符合下面的要求。

#include <iostream>
#include <map>
using namespace std;
// 在此处补充你的代码
int A::count = 0;
void func(B b) { }
int main()
{
        A a1(5),a2;
        cout << A::count << endl;
        B b1(4);
        cout << A::count << endl;
        func(b1);
        cout << A::count << endl;
        A * pa = new B(4);
        cout << A::count << endl;
        delete pa;
        cout << A::count << endl;
        return 0;
}

输入
不需要输入。

输出
使得程序的输出结果是：
2
3
B::destructor
A::destructor
3
4
B::destructor
A::destructor
3
B::destructor
A::destructor
A::destructor
A::destructor

样例输入

不需要输入。

样例输出

2
3
B::destructor
A::destructor
3
4
B::destructor
A::destructor
3
B::destructor
A::destructor
A::destructor
A::destructor

提示
int A::count = 0; 这个变量是用来记录一共有多少个类A及类A的派生类的对象的。

程序解答（带注释）：

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

// 在此处补充你的代码
class A{
public:
    static int count;  //必须是静态的，用来记录一共有多少个类A及类A的派生类的对象

    A(){ count++; }
    A(int n){ count++; }

    virtual ~A(){   //析构函数（对象消亡时自动被调用）
        //count--;  此时类的对象没有消亡，程序结束时才消亡，所以 count 的值不减少
        cout << "A::destructor" << endl;
    }

    //重载delete，使用了delete释放某个重载了delete的类的对象空间时，先调用类的析构函数，然后再调用重载的delete函数。
    void operator delete(void* a){ count--; }
};

class B :public A{
public:
    B(int n){}  //调用派生类的构造函数之前要先调用基类的构造函数！此处默认调用的是基类的 A() 构造函数
    //B(int n):A(){}  //也可以

    ~B(){      //virtual ~B() 也可以，此处 ~B() 自动是虚的
        //count--;  此时类的对象没有消亡，程序结束时才消亡，所以 count 的值不减少
        cout << "B::destructor" << endl;
    }
};

int A::count = 0;
void func(B b) { }
int main()
{
    A a1(5), a2;
    cout << A::count << endl;  //输出 2
    B b1(4);
    cout << A::count << endl;  //输出 3

    //注：这里函数 func(b1) 作用结束后，其作用对象 b1 就会消亡！ 3.2.3 讲义 析构函数（对象消亡时自动被调用）
    func(b1);                  //输出 B::destructor
                               //输出 A::destructor

    cout << A::count << endl;  //输出 3
    A * pa = new B(4);
    cout << A::count << endl;  //输出 4

    delete pa;   //此处 new B(4)对象 消亡，所以 count 的值减 1
                               //输出 B::destructor
                               //输出 A::destructor

    cout << A::count << endl;  //输出 3

    return 0;
}

程序解答（带注释及验证）：

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

// 在此处补充你的代码
class A{
public:
    static int count;  //必须是静态的，用来记录一共有多少个类A及类A的派生类的对象

    A(){ count++; cout << "  a()" << count << endl; }
    A(int n){ count++; cout << "  a" << count << endl; }

    virtual ~A(){   //析构函数（对象消亡时自动被调用）
        //count--;  此时类的对象没有消亡，程序结束时才消亡，所以 count 的值不减少
        cout << "A::destructor" << endl;
    }

    //重载delete，使用了delete释放某个重载了delete的类的对象空间时，先调用类的析构函数，然后再调用重载的delete函数。
    void operator delete(void* a){ count--; }
};

class B :public A{
public:
    B(int n){ cout << "  b" << count << endl; }  //调用派生类的构造函数之前要先调用基类的构造函数！此处默认调用的是基类的 A() 构造函数
    //B(int n):A(){}  //也可以

    ~B(){      //virtual ~B() 也可以，此处 ~B() 自动是虚的
        //count--;  此时类的对象没有消亡，程序结束时才消亡，所以 count 的值不减少
        cout << "B::destructor" << endl;
    }
};

int A::count = 0;
void func(B b) { }
int main()
{
    A a1(5), a2;
    cout << A::count << endl;  //输出 2
    B b1(4);
    cout << A::count << endl;  //输出 3

    //注：这里函数 func(b1) 作用结束后，其作用对象 b1 就会消亡！ 3.2.3 讲义 析构函数（对象消亡时自动被调用）
    func(b1);                  //输出 B::destructor
                               //输出 A::destructor

    cout << A::count << endl;  //输出 3
    A * pa = new B(4);
    cout << A::count << endl;  //输出 4

    delete pa;   //此处 new B(4)对象 消亡，所以 count 的值减 1
                               //输出 B::destructor
                               //输出 A::destructor

    cout << A::count << endl;  //输出 3

    return 0;
}

有关 func(b1) 的解释：