避免在析构函数中编写代码

上篇文章中，我们介绍了为什么应该彻底避免编写拷贝构造函数和赋值操作符。今天这篇我们讨论下为什么应该避免在析构函数中编写代码。即让析构函数为空。

例如：

virtual ~MyClass()
{
}

我们用空析构函数这个术语表示花括号内没有代码的析构函数。

需要编写析构函数可能有如下几个原因：

• 在基类中，可能需要声明虚拟析构函数，这样就可以使用一个指向基类的指针指向一个派生类的实例。
• 在派生类中，并不需要把析构函数声明为虚拟函数，但是为了增强可读性，也可以这样做。
• 可能需要声明析构函数并不抛出任何异常。

对于最后一种情况，我们将详细讨论。在C++中，从析构函数中抛出异常被认为是不好的思路。这是因为析构函数常常是在一个异常已经被抛出的情况下被调用的，在这个过程中再次抛出异常将导致程序终止（或崩溃），这很可能违背程序员的初衷。因此，在有些类中，析构函数被声明为如下：

virtual ~ScppAssertFailedException() throw ()
{
}

这意味着我们保证不会从这个析构函数中抛出异常。因此，我们可以看到有时候需要编写析构函数。现在我们可以讨论析构函数为什么应该为空。何时需要在析构函数中出现实质性的代码呢？只有在析构函数或类的其他方法中获取了一些资源，并且在这个类的对象被销毁时应该释放这些资源时才应该这样，例如：

class PersonDescription
{
public:
	PersonDescription(const char* first_name, const char* last_name)
		: first_name_(NULL), last_name_(NULL)
	{
		if(first_name != NULL)
			first_name_ = new string(first_name);
		if(last_name != NULL)
			last_name_ = new string(last_name);
	}

	~PersonDescription()
	{
		delete first_name_;
		delete last_name_;
	}

private:
	PersonDescription(const PersonDescription&);
	PersonDescription& operator = (const PersonDescription&);

	string* first_name_;
	string* last_name_;
};

这个类的设计违背了我们在前几篇文章中所讨论的原则。首先，我们看到每次添加一个表述个人描述的新元素时，都需要在析构函数中 添加对应的清理代码，这就违背了“不要迫使程序记住某些事情”的原则。以下是改进的设计代码：

class PersonDescription
{
public:
	PersonDescription(const char* first_name, const char* last_name)
		: first_name_(NULL), last_name_(NULL)
	{
		if(first_name != NULL)
			first_name_ = new string(first_name);
		if(last_name != NULL)
			last_name_ = new string(last_name);
	}
private:
	PersonDescription(const PersonDescription&);
	PersonDescription& operator = (const PersonDescription&);

	string* first_name_;
	string* last_name_;
};

在这个例子中，我们根本不需要编写析构函数，因为编译器会为我们自动生成一个析构函数完成这些任务，在减少工作量的同时，也减少了出现脆弱代码的可能性。但是，这并不是选择第二种设计的主要原因。在第一个例子当中，存在一种更为严重的潜在危害。

假设我们决定增加安全检查，检查调用者是否提供了名字和姓氏：

class PersonDescription
{
public:
	PersonDescription(const char* first_name, const char* last_name)
		: first_name_(NULL), last_name_(NULL)
	{
		<span style="color:#ff0000;">SCPP_ASSERT(first_name != NULL ,"First name must be provided");
		first_name_ = new string(first_name);
        
		SCPP_ASSERT(last_name != NULL ,"Last name must be provided");
		last_name_ = new string(last_name);</span>
	}
	
	~PersonDescription()
	{
		delete first_name_;
		delete last_name_;
	}
private:
	PersonDescription(const PersonDescription&);
	PersonDescription& operator = (const PersonDescription&);

	string* first_name_;
	string* last_name_;
};

正如我们之前讨论的那样，程序中的错误可能会终止程序，但也有可能抛出一个异常。现在我们就陷入这种麻烦之中：从构造函数抛出异常是一种不好的思路。为何呢？如果我们试图在堆栈上创建一个对象，并且构造函数正常的完成了它的任务（不抛出异常），那么当这个对象离开作用域之后，它的析构函数会被调用。但是，如果构造函数并没有完成它的任务，而是抛出了一个异常，析构函数将不会被调用。

因此，在前面的例子当中，如果我们假设提供了名字却没有提供姓氏，表示名字的字符串将被分配内存，但永远不会被删除，因此导致了内存泄露。但是，情况还不至于无可挽回。更进一步观察，如果我们有一个包含了其他对象的对象，一个重要的问题是：哪些析构函数将被调用？哪些析构函数将不被调用？

以下是用一个小试验来说明：

class A 
{
public:
	A()
	{
		cout<<"Creating A"<<endl;
	}
	~A()
	{
		cout<<"Destroying A"<<endl;
	}
};

class B 
{
public:
	B()
	{
		cout<<"Creating B"<<endl;
	}
	~B()
	{
		cout<<"Destroying B"<<endl;
	}
};

class C  : public A
{
public:
	C()
	{
		cout<<"Creating C"<<endl;
		Throw "Don't like C";
	}
	~C()
	{
		cout<<"Destroying C"<<endl;
	}

private:
	B b_;
};

注意，C类通过合成（即C类拥有一个B类型的数据成员）包含了B类。它还通过继承包含了A类型的对象（即在C类型的对象内部有一个A类型的对象）。现在，如果C的构造函数抛出一个异常，会发生什么情况呢？看以下的代码：

int main()
{
	cout<<"Testing throwing from constructor."<<endl;
	try{
		C c;
	}catch(...)
	{
		cout<<"Caught an exception."<<endl;
	}

	return 0;
}

运行后将产生下面的输出：

Testing throwing from constuctor.
Creating A
Creating B
Creating C
Destroying B
Destroying A
Caught an exception.

注意，只有C的析构函数没有被执行，A和B的析构函数都被调用。因此上面问题的答案既简单又符合逻辑：对于允许构造函数正常结束的对象，析构函数将会被调用，即使这些对象是一个更大对象的一部分，而后者的构造函数并没有正常结束。因此，让我们用智能指针重写上面的示例代码，引入安全检查：

class PersonDescription
{
public:
	PersonDescription(const char* first_name, const char* last_name)
		: first_name_(NULL), last_name_(NULL)
	{
		SCPP_ASSERT(first_name != NULL ,"First name must be provided");
		first_name_ = new string(first_name);
        
		SCPP_ASSERT(last_name != NULL ,"Last name must be provided");
		last_name_ = new string(last_name);
	}
	
	~PersonDescription()
	{
		delete first_name_;
		delete last_name_;
	}
private:
	PersonDescription(const PersonDescription&);
	PersonDescription& operator = (const PersonDescription&);

	<span style="color:#ff0000;">scpp::ScopedPtr<string> first_name_;
	scpp::ScopedPtr<string> last_name_;</span>
};

即使第2个安全检查抛出一个异常，指向first_name_的智能指针的析构函数仍然会被调用，并执行它的清理工作。另一个附带的好处是，我们并不需要操心把这些智能指针初始化为NULL，这是自动完成的。因此，我们看到从构造函数抛出异常是一种潜在的危险行为：对应的析构函数将不会被调用，因此可能会存在问题，除非析构函数是空函数。

总结：

从构造函数中抛出异常时为了避免内存泄露，在设计类的时候，使析构函数保持为空函数。