构造析构的妙用－－成对出现
考虑这样一段代码：
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都将被销毁，析构函数被执行，锁被解开，彻
底解决了死锁的问题，解决的很完美。
同样在其他有成对出现的情况下都可以考虑使用构造和析构函数。
