资源需要分配,同样也是需要销毁的.<程序员修炼之道>中原则35,”finish what you start”说的便是这个道理..

下面是一个很糟糕的程序,它打开文件,读取信息,更新字段,然后写回结果.’

FILE *fd;

void readObject(const char *filePath, Object *obj)
{
	fd = fopen(filePath, "r+");
	fread(obj, sizeof(*obj), 1, fd);
}

void WriteObject(Object *obj)
{
	rewind(fd);
	fwrite(obj, sizeof(*obj), 1, fd);
	fclose(fd);
}

void updateObject(const char *filePath, int weight)
{
	Object obj;
	readObject(filePath, &obj);
	obj.weight = weight;
	writeObject(&obj);
}

乍看起来,程序可以工作得很好.但是,因为共享fd,readObject和writeObject却紧紧的耦合在一起了.可以很轻松的举一个例子,证明两个函数耦合带来的问题.比如说,要求仅在weight大于100时才做更新,那么updateObject函数将被修改为,

void updateObject(const char *filePath, int weight)
{
	Object obj;
	readObject(filePath, &obj);
	if(weight > 100)
	{	
		obj.weight = weight;
		writeObject(&obj);
	}
}

这就引入了一个问题,WriteObject在某些情况下并不会被调用,以致于文件未被关闭,这将浪费系统的资源.

一种解决方案可以是

void updateObject(const char *filePath, int weight)
{
	Object obj;
	readObject(filePath, &obj);
	if(weight > 100)
	{	
		obj.weight = weight;
		writeObject(&obj);
	}
	else fclose(fd);
}

这看起来貌似不错,不管新的weight是多少,文件总是会被关闭..但其实,这是一个非常糟糕的修改,readObject,writeObject和updateObject三个函数由于共享fd耦合在一起了.简单的web服务器中的代码就是如此,爬出一个陷阱,却掉进了一个更大的坑,这不得不说是种悲剧.

要解决这个问题,可以遵守一个原则,资源的分配和销毁这一责任由同一个函数承担,打开和关闭在同一地方,而且配对出现.重构如下:

void readObject(FILE *fd, Object *obj)
{
	fread(obj, sizeof(*obj), 1, fd);
}

void WriteObject(FILE *fd, Object *obj)
{
	rewind(fd);
	fwrite(obj, sizeof(*obj), 1, fd);
}

void updateObject(const char *filePath, int weight)
{
	FILE *fd;
	Object obj;
	
	fd = fopen(filePath, "r+"); 
	readObject(fd, &obj);  
	if(weight > 100)         
	{	                          
		obj.weight = weight;
		writeObject(fd, &obj);
	}                                        
	fclose(fd); 
}

这样做还有一个附加的好处–去掉丑陋的全局变量FILE *fd.

异常下的资源分配和释放

在使用异常时,很容易写出这样的代码,

void doit()
{
	Node *n = new Node;
	try
	{
		// do something
	}
	catch(...)
	{
		delete n;
		throw;
	}
	delete n;
}

注意到,n是在两个地方被释放的,一次是在程序正常路径上,一次是在异常处理中.这显然是违反DRY(Dont repeat yourself)原则的,也许会像前面一样导致维护问题.

解决上面的问题,其实可以用到3种小技巧.一是,利用C++的性质–局部变量在作用域外会被自动销毁.如果允许的话,我们可以将’n’从指针变为栈上的实际的对象.

void doit1()
{
	Node n;
	try
	{
		// do something
	}
	catch(...)
	{
		throw;
	}
}

这样,不管是否抛出异常,C++都将自动析构Node对象.

当然,由于各种原因,用对象替代指针的做法可能是不被允许的.变通方法很简单,我们可以将指针包装在另外一个类中,

class NodePointer
{
	Node *n;
public:
	NodePointer() { n = new Node; }
	~NodePointer() {delete n; }
};

void doit2()
{
	NodePointer n;
	try
	{
		// do something
	}
	catch(...)
	{
		throw;
	}
}

最后一种方法是直接利用C++库中的模板类auto_ptr,它将自动包装动态分配的对象.

void doit3()
{
	auto_ptr<Node> p (new Node);  // 用p->访问.
	try
	{
		// do something
	}
	catch(...)
	{
		throw;
	}
}