構造解構函式的妙用－成對出現 (轉)

構造解構函式的妙用－成對出現 (轉)[@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都將被銷燬，解構函式被執行，鎖被解開，徹

底解決了死鎖的問題，解決的很完美。

同樣在其他有成對出現的情況下都可以考慮使用構造和解構函式。