【Effective C++】不要在构造函数和析构函数中调用 virtual 函数

首先结论如标题所示。


如果你有一个类的继承体系，用来模拟股票交易市场的买进卖出，并且每一笔交易都需要进行记录，那么可能会有如下的类继承关系：

class Transaction {
public:
	Transaction()
	{
		//...
		LogTransaction();
	}

	virtual void LogTransaction() const = 0;
};

class BuyTransaction : public Transaction
{
public:
	BuyTransaction(){}
	void LogTransaction() const override {
		//...
	}
};

class SellTransaction : public Transaction
{
public:
	SellTransaction(){}
	void LogTransaction() const override {
		//...
	}
};

当执行到下面这一行时，会发生什么事情呢？

BuyTransaction buyTrans;

程序在运行的时候就会报错：
错误 LNK2019 无法解析的外部符号 "public: virtual void __thiscall Transaction::LogTransaction(void)const " (?LogTransaction@Transaction@@UBEXXZ)，该符号在函数 “public: __thiscall Transaction::Transaction(void)” (??0Transaction@@QAE@XZ) 中被引用

究其原因，如下：
子类 BuyTransaction 的构造函数在调用的时候，会先调用父类 Transaction 的构造函数。而在父类的构造函数中有一个虚函数 LogTransaction 的调用，这个时候，虚函数 LogTransaction 的调用是调用的父类 Transaction 的版本，而不是我们预想的子类 BuyTransaction 的版本，即使目前即将建立的对象是 BuyTransaction 类型。而在父类中 LogTransaction 它是一个 pure virtual function，并没有实现，所以连接器才会找不到实现，提示无法解析。

我们也可以稍微修改一个上面的代码，来验证以上说法：

class Transaction {
public:
	Transaction()
	{
		//...
		LogTransaction();
	}

	virtual void LogTransaction() const
	{
		std::cout << "class \"Transaction\" called function \"LogTransaction\"";
	}
};

class BuyTransaction : public Transaction
{
public:
	BuyTransaction(){}
	void LogTransaction() const override 
	{
		std::cout << "class \"BuyTransaction\" called function \"LogTransaction\"";
	}
};

class SellTransaction : public Transaction
{
public:
	SellTransaction(){}
	void LogTransaction() const override 
	{
		std::cout << "class \"SellTransaction\" called function \"LogTransaction\"";
	}
};


int main()
{
	BuyTransaction buyTrans;
	system("pause");
}

将 pure virtual function 修改为了 normal virtual function，即父类提供 LogTransaction 的实现，这个时候，输出的正是：

class "Transaction" called function "LogTransaction“

验证了在 base class 的构造期间，virtual 函数并不是 virtual 函数，无法实现多态。也就说，在这个期间，对象的类型不是 derived class，而是 base class。

其实这个原因也很好想。base class 的构造函数要先于 derived class 的构造函数执行，当 base class 构造函数在执行时，derived class 的成员变量都还没有进行初始化。我们知道多态的实现是利用指向虚函数表的指针实现的，这个时候子类都还没有构造成功，这个虚函数指针都没有初始化正确指向虚函数表，怎么可能会实现多态的调用呢？
其实，不只是 virtual 函数会被编译器解析至 base class，想其他的运行期的类型信息，如 dynamic_cast，typeid，也会把对象视作 base class 类型。


相同的道理也适用于析构函数。一旦 derived class 的析构函数开始执行，对象内的 derived class 成员变量便会呈现未定义值，进入 base class 析构函数之后对象便成为了一个 base class 对象。


那如何解决这个问题呢？一种做法是将 virtual 函数变为 non-virtual 函数，然后要求 derived class 传递必要的信息给 base class，然后 base class 的构造函数就可以放心的调用这个 non-virtual 版本：

class Transaction {
public:
	//让子类传递必要的构造信息
	explicit Transaction(const std::string& logInfo)
	{
		//...
		LogTransaction(logInfo);
	}

private:
	//变为 non-virtual 函数
	void LogTransaction(const std::string& logInfo) const
	{
		//记录信息
	}
};

class BuyTransaction : public Transaction
{
public:
	BuyTransaction() : Transaction(createLogString(parameters))
	{

	}

private:
	static std::string createLogString(parameters);
};