构造析构函数的妙用－成对出现 (转)

构造析构函数的妙用－成对出现 (转)[@more@]

构造析构的妙用－－成对出现

考虑这样一段代码：
void some_func()
{
 lock(key);
 ……
 ……
 unlock(key);
}
由于对some_func的不能并发访问，所以在函数的开始处加上锁key，只有key处

于解锁状态，lock才可以返回，当函数执行完毕后unlock，其他进程调用lock

方能成功，从而可以得以执行some_func。

在函数体内如果出现这样的情况：
void some_func()
{
 lock(key);
 .....
 if(something)
  return;
 .....
 unlock(key);
}
函数某些条件的判断而返回，这样，some_func存在了大于一个返回点，这样由

于没有执行unlock操作，其他进程或本进程对some_func的再次访问将被死锁而

永远无法得以执行。
如果我们这样解决问题：
void some_func()
{
 lock(key);
 .....
 if(something)
 {
  unlock(key);
  return;
 }
 .....
 unlock(key);
}
这样可以解决部分问题，但是如果函数返回点很多，就需要在每个返回点进行

解锁unlock操作，很麻烦，同时它还存在如下问题：
void some_func()
{
 lock(key);
 ....
 my_func();//由其他程序员实现的函数。
 .....
 unlock(key);
}
看起来一点问题也没有，但是如果my_func()丢出异常呢？
如果我们函数里没有捕获这个异常的话 ，它会导致 some_func 函数在调用

my_func的这一点中断。那么只能在每个可能抛出异常的函数调用点用 try 捕

获所有异常，然后在 catch 里面解锁，再重新抛出。显然，这样的解法实在是

太繁琐、太容易引入错误了。

如果我们这样考虑，锁和解锁的操作是要成对出现的，而对于一个类而讲，构

造和析构函数也是成对出现的，我们可以这样设计：
class auto_lock
{
public:
 auto_lock(lock_t key) : m_key(key)
 {
  lock(m_key);// 构造时加锁
 }
 ~auto_lock()
 {
  unlock(m_key)// 析构时解锁
 }

private:
 lock_t m_key;
}

void some_func()
{
 auto_lock my_lock(key);
 ……
 // return 、foo ，随便什么东西都行
 ……
 // 结束的时候同样不用解锁
}
由于my_lock是一个局部变量，他的生命周期在函数some_func内，不论some_fu

nc以什么样的方式退出，my_lock都将被销毁，析构函数被执行，锁被解开，彻

底解决了死锁的问题，解决的很完美。

同样在其他有成对出现的情况下都可以考虑使用构造和析构函数。

来自 “ ITPUB博客 ” ，链接：http://blog.itpub.net/10752019/viewspace-963005/，如需转载，请注明出处，否则将追究法律责任。

转载于:http://blog.itpub.net/10752019/viewspace-963005/