爲什麼在數組創建過程中當未捕獲的異常拋出C++時調用析構函數？

Question

class XX 
{ 
public: 
    static unsigned s_cnt; 
    XX() 
    { 
     ++ s_cnt; 
     std::cout << "C XX " << s_cnt << "\n"; 

     if (s_cnt > 2) 
      throw std::exception(); 
    } 

    //private: 
    ~XX() 
    { 
     std::cout << "~ XX\n"; 
    } 
}; 
unsigned XX::s_cnt = 0; 

int main() 
{ 
    try 
    { 
     XX *xx = new XX[10]; 
    } catch (...) 
    { 
     std::cout << "Exc\n"; 
    } 
} 

輸出：

C XX 1 
C XX 2 
C XX 3 
~ XX 
~ XX 
Exc 

但是，當我刪除的try-catch，我看到：

C XX 1 
C XX 2 
C XX 3 
terminate called after throwing an instance of 'std::exception' 
    what(): std::exception 
zsh: abort  ./a.out 

爲什麼C++調用在第一種情況下的析構函數，但不是在第二？

Answer 1

當你不捕捉異常（即它成爲一個未捕獲的異常而終止程序），C++不給你，實際上析構函數被調用的任何保證。

這給出如何實現異常處理的編譯器餘地。例如，GCC首先搜索處理程序。如果找不到，它會立即中止，保存完整的堆棧信息以進行調試。如果它確實找到了它，它實際上會放出堆棧，銷燬對象，直到它到達處理程序。這就是爲什麼你看不到輸出：程序在銷燬任何對象之前中止。

Answer 2

當您從構造函數中拋出異常時，該標準將該對象視爲未構造。你不會毀掉那些不存在的東西，不是嗎？

事實上，即使這個簡單的例子不按照你的建議的工作：

struct A { 
    A() {throw std::exception();} 
    ~A() {std::cout << "A::~A()" << std::endl;} 
}; 

int main() { 
    A a; 
} 

這終止與未捕獲到異常，但不打印「A ::〜A（）」。

如果你想想看，這是給一個語義它的唯一可能的方式。

例如，我們可以使用我們的類型A作爲B類成員對象：

struct B { 
    B() : m_a(),m_p(new int) {} 
    ~B() {delete m_p;} 

    A m_a; 
    int * m_p; 
}; 

顯然B::B()立即引發（和甚至不初始化m_p）。如果在這種情況下假設的C++標準要求調用B::~B()，則析構函數無法知道m_p是否已被初始化。

換句話說，從構造函數拋出異常意味着該對象從不存在，它的生命週期從未開始。這個GotW很清楚。

獎勵：如果在B的定義中我們交換了m_a和m_p的訂單會發生什麼？ 然後你有內存泄漏。這就是爲什麼在成員對象的初始化過程中存在一種特殊的語法來捕獲異常。