【C++ Primer | 15】面试问题

在成员函数中调用虚函数

#include <iostream>
using namespace std;
class CBase
{
public:void func1(){func2();}virtual void func2()  {cout << "CBase::func2()" << endl;}
};
class CDerived:public CBase
{
public:virtual void func2() { cout << "CDerived:func2()" << endl; }
};
int main()
{CDerived d;d.func1();return 0;
}

输出结果：

CDerived:func2()

分析：

第 20 行调用 func1 成员函数。进入 func1 成员函数，执行到第 8 行，调用 func2 函数。看起来调用的应该是 CBase 类的 func2 成员函数，但输出结果证明实际上调用的是 CDerived 类的 func2 成员函数。
这是因为，在 func1 函数中，func2();等价于this -> func2();，而 this 指针显然是 CBase* 类型的，即是一个基类指针，那么this -> func2();就是在通过基类指针调用虚函数，因此这条函数调用语句就是多态的。
当本程序执行到第 8 行时，this 指针指向的是一个 CDerived 类的对象，即 d，因此被调用的就是 CDerived 类的 func2 成员函数。

在构造函数和析构函数中调用虚函数

#include <iostream>
using namespace std;
class A
{
public:virtual void hello() { cout << "A::hello" << endl; }virtual void bye() { cout << "A::bye" << endl; }
};
class B : public A
{
public:virtual void hello() { cout << "B::hello" << endl; }B() { hello(); }~B() { bye(); }
};
class C : public B
{
public:virtual void hello() { cout << "C::hello" << endl; }
};
int main()
{C obj;return 0;
}

输出结果：

B::hello
A::bye

类 A 派生出类 B，类 B 派生出类 C。
第 23 行，obj 对象生成时会调用类 B 的构造函数，在类 B 的构造函数中调用 hello 成员函数。由于在构造函数中调用虚函数不是多态，所以此时不会调用类 C 的 hello 成员函数，而是调用类 B 自己的 hello 成员函数。
obj 对象消亡时，会引发类 B 析构函数的调用，在类 B 的析构函数中调用了 bye 函数。类B没有自己的 bye 函数，只有从基类 A 继承的 bye 函数，因此执行的就是类 A 的 bye 函数。
将在构造函数中调用虚函数实现为多态是不合适的。以上面的程序为例，obj 对象生成时，要先调用基类构造函数初始化其中的基类部分。在基类构造函数的执行过程中，派生类部分还未完成初始化。此时，在基类 B 的构造函数中调用派生类 C 的 hello 成员函数，很可能是不安全的。

为什么基类中的析构函数要声明为虚析构函数？

直接的讲，C++中基类采用virtual虚析构函数是为了防止内存泄漏。具体地说，如果派生类中申请了内存空间，并在其析构函数中对这些内存空间进行释放。假设基类中采用的是非虚析构函数，当删除基类指针指向的派生类对象时就不会触发动态绑定，因而只会调用基类的析构函数，而不会调用派生类的析构函数。那么在这种情况下，派生类中申请的空间就得不到释放从而产生内存泄漏。所以，为了防止这种情况的发生，C++中基类的析构函数应采用virtual虚析构函数。

测试代码：

#include <iostream>
#include <memory>
using namespace std;class Base {
public:Base() { cout << "Base Constructor" << endl; }~Base() { cout << "Base Destructor" << endl; }
};class Derived : public Base {
public:Derived() { cout << "Derived Constructor" << endl; }~Derived() { cout << "Derived Destructor" << endl; }
};int main() 
{Base* p = new Derived();delete p;return 0;
}

输出结果：

Base Constructor
Derived Constructor
Base Destructor

测试代码

#include <iostream>
#include <memory>
using namespace std;class Base {
public:Base() { cout << "Base Constructor" << endl; }virtual ~Base() { cout << "Base Destructor" << endl; }
};class Derived : public Base {
public:Derived() { cout << "Derived Constructor" << endl; }virtual ~Derived() { cout << "Derived Destructor" << endl; }
};int main()
{Base* p = new Derived();delete p;return 0;
}