条款09：绝不在构造和析构过程中调用virtual函数-CSDN博客

本文链接：https://blog.csdn.net/lym940928/article/details/81099795

条款09：绝不在构造和析构过程中调用virtual函数

Never call virtual functions during construction of destruction.

derived class中，base class的初始化先于derived class

之所以不要在构造函数和析构函数起点调用virtual函数，是因为这种调用并不会带来预期的结果。

举个例子，假设有这样一个class继承体系，用来模拟股市的买进、卖出的订单等。在这样的过程中，一定要经过审计，因此每当创建一个交易对象时，在审计日志（audit log）中也需要创建一笔适当的记录：

class Transaction {         //所有交易的base class
public:
    Transaction();
    virtual void logTransaction() const = 0;  //做出一份因为类型不同而不同的日志记录，目前是一个纯虚函数
    ...
};

Transaction::Transaction()  //base class的构造函数的实现
{
    ...
    logTransaction();    //最后的动作是对这笔交易进行记录
}

class BuyTransaction: public Transaction {    //derived class
public:
    virtual void logTransaction() const;   //对这种类型的交易进行记录（log）
    ...
};

class SellTransaction: public Transaction {   //derived class
public:
    virtual void logTransaction() const;   //对这种类型的交易进行记录（log）
    ...
};

当我们执行如下语句时：

BuyTransaction b;

此时，一定会有一个BuyTransaction构造函数被调用，但是，首先Transaction构造函数一定会更早的被调用，即：

derived class对象内的base class成分会在derived class自身成分被构造之前先完成构造。

然而，Transaction构造函数中的virtual函数logTransaction却会引发问题。
因为此时所调用的logTransaction是Transaction内的版本，而不是BuyTransaction内的版本——即使目前即将创建的对象是BuyTransaction。即：

base class构造期间，virtual函数绝不会下降到derived classes阶层。

换种说法，即：

在base class构造期间，virtual函数不是virtual函数。（虚非虚）

更根本的原因在于：在derived class对象的base class构造期间，对象的类型是base class而不是derived class。不止virtual函数会被编译器解析至（resolve to）base class，若使用运行期间类型信息，也会把对象视为base class。
在上面的例子中，当Transaction构造函数正在执行起来，打算初始化“BuyTransaction对象内的base class成分”时，该对象的类型是Transaction。而这个对象内的“BuyTransaction专属成分”尚未被初始化。因此在面对它们时，最安全的做法就是视它们不存在。总之：

对象在derived class构造函数开始执行之前不会成为一个derived class对象。

相同的道理同样适用于析构函数。
一旦derived class析构函数开始执行，对象内的derived class成员变量便呈现出未定义值。因此，C++将其视为仿佛不存在。进入base class析构函数后对象就变成了一个base class对象。

因此，在上面的例子中，Transaction构造函数直接调用一个virtual函数，这很明显就违反了该条款的内容。
因为logTransaction函数在Transaction内是一个pure virtual（纯虚函数）。除非它被定义了，否则程序无法连接，因为连接器找不到必要的Transaction::logTransaction实现代码。

但是，侦测“构造函数或析构函数运行期间是否调用virtual函数”并不简单。
如果Transaction有多个构造函数，每个都需要执行某些相同的工作，那么避免代码重复的一个优秀做法就是将共同的初始化代码（包括对logTransaction的调用）都放到一个初始化函数如init内：

class Transaction {
public:
    Transaction()    //调用non-virtual（init()是non-virtual）
    {  init();  }
    virtual void logTransaction() const = 0;
    ...
private:
    void init()
    {
        ...
        logTransaction();    //调用了virtual！！
    }
};

上面的这段代码，和早期的版本是一样的，但是却有更深层次的危害，因为这样并不会引起编译器和连接器的报错。
此时，由于logTransaction是Transaction的一个pure virtual函数，当pure virtual函数被调用是，大多执行系统会终止程序。
然而，如果logTransaction是个正常的virtual（即impure）函数，并在Transaction内带有一份代码，该版本就会被调用，程序也会继续往下进行，只会造成创建一个derived class对象时会调用错误版本的logTransaction。
为了避免这一问题，解决办法为：

保证构造函数和析构函数都没有（在对象被创建和销毁期间）调用virtual函数，而他们调用的所有函数也都服从同一约束。

但是，又如何确保每一次都有Transaction继承体系上的对象被创建，就会有适当版本的logTransaction被调用？
解决办法为：

一种办法是在class Transaction内将logTransaction函数改为non-virtual，然后要求derived class构造函数传递必要的信息给Transaction构造函数，而后那个构造函数边可以安全的调用non-virtual logTransaction。

即：

class Transaction {
public:
    explicit Transaction(const std::string& logInfo);
    void logTransaction(const std:;string& logInfo) const;//此时，是一个non-virtual函数
    ...
};

Transaction::Transaction(const std::string& logInfo)
{
    ...
    logTransaction(logInfo);    //此时，是一个non-virtual调用
}

class BuyTransaction: public Transaction {
public: 
    BuyTransaction( parameters )
        : Transaction(createLogString( parameters )) //将log信息传递给base class构造函数
        { ... }
    ...
private:
    static std::string createLogString( parameters );
};

换句话说，由于无法使用virtual函数从base class**向下调用，在构造期间，可以由“令derived classes将必要的构造信息向上传递至base class构造函数**”替换并加以弥补。

在上面的例子中，需要注意BuyTransaction中的private static函数createLogString的运用。利用这种辅助函数创建一个值传给base class构造函数比较方便并且更可读。令这个函数为static，也就不可能意外指向“初期未成熟的BuyTransaction对象内尚未初始化的成员对象”。正式因为“那些成员变量处于未定义状态”，所以“在base class构造函数和析构函数期间调用的virtual函数不可下降至derived classes”。

最后：