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

  在C++中，不应该在构造函数和析构函数期间调用virtual函数。

  这里有一个模拟股市交易的类：

class Transaction{                                //所有交易的base class
public:    
    Transaction();                                
    virtual void logTranstion() const = 0;        //作出一份因类型不同而不同的日志记录
    ...
};


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

class BuyTransaction:public Transction            //derived class
{
public:
    virtual void logTranstion() const;            //记录此交易
    ...
}；

class SellTransction: public Transction            //derived class
{
public:
    virtual void logTranstion() const;            //记录此交易
    ...
}；

 当执行以下代码时，会发生什么事：

BuyTransaction b;

   很显然会有一个BuyTransaction构造函数被调用，但肯定先执行其base class的构造函数。而在base class调用的logTransion不是BuyTransaction内的版本。在base class构造期间，virtual函数不是virtual函数。

  由于base class构造函数的执行更早于derived class构造函数，当base class构造函数执行时derived class的成员变量尚未初始化。如果此期间调用的virtual函数下降至derived class阶层，derived class的函数几乎必须调用local本地成员变量，而那些成员变量尚未初始化。

  在devrived class对象的base class构造期间，对象的类型是base class而不是derived class。virtual函数会被编译器解析至base class，如果使用运行期类型信息，也会把对象视为base class类型。

  而对于析构函数。一旦derived class析构函数开始执行，对象内的derived class成员变量便呈现未定义值，所以C++视它们仿佛不再存在。进入base class析构函数后对象就成为一个base class对对象。

  如果Transaction函数有多个构造函数，每个都需要执行某些相同工作，那么避免代码重复的一个优秀做法是把共同的的初始化代码（包括对logTransaction的调用）放进一个init内：

  

class Transaction
{
public:
    Transaction()
    { init(); }                            //调用non-virtual
    virtual void logTransaction() const  = 0;
    ...
private:
    void init()
    {
        logTransaction();                //这里调用virtual
    }
}

  这段代码通常不会引发任何编译器和连接器的抱怨。此时由于logTransaction是Transaction内pure virtual函数，大多数执行系统会中止程序（通常会对此结果发出一个信息）。然而如果logTransaction是个impure virtual函数，并在Transaction内有一份实现代码，该版本就会被调用，而在建立一个derived class对象时就会调用一个错误版本的logTransaction。

  唯一能够避免此问题的做法就是：确定你的构造函数和析构函数都没有（在对象被创建和销毁期间）调用virtual函数，而它们调用的函数也符合这一约束。

  因为我们不能确保Transaction继承体系上的对象被创建，就会有适当版本的logTrans被调用。所以我们可以将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)
    : Transacion(createLogString(parameters))             //将log信息传递给base class构造函数
    {...}
    ...
private:
    static std::string createLogString(parameters);   
};

  由于我们无法使用virtual函数从base class从下调用，在构造期间，你可以“令derived 函数将必要的信构造息向上传递至base class构造函数”。

  BusTransaction的private static 函数createLogString比起在成员初始列内给予base class所需数据，利用辅助函数创建一个值传递给base class构造函数往往比较方便，也比较可读。令次函数为static可以确保不指向BuyTransaction对象的尚未初始化的变量.。

 

结论：在构造函数和析构函数不要调用virtual函数，因为这类调用不会从不下降至derived class。