首先，我們要明確一點！一個函式執行的過程中，如果丟擲異常，會導致函式提前終止！

在C++建構函式中，既需要分配記憶體，又需要丟擲異常時要特別注意防止記憶體洩露的情況發生。因為在建構函式中丟擲異常，在概念上將被視為該物件沒有被成功構造，因此當前物件的解構函式就不會被呼叫。同時，由於建構函式本身也是一個函式，在函式體內丟擲異常將導致當前函式執行結束，並釋放已經構造的成員物件，包括其基類的成員，即執行直接基類和成員物件的解構函式。所以在建構函式中儘量不要丟擲異常，但可以丟擲異常（後面給出方法），要注意記憶體洩漏的問題！

舉個栗子：

#include <iostream>
using namespace std;

class C
{
    int m;
public:
    C(){cout<<"in C constructor"<<endl;}
    ~C(){cout<<"in C destructor"<<endl;}
};

class A
{
public:
    A(){cout<<"in A constructor"<<endl;}
    ~A(){cout<<"in A destructor"<<endl;}
};

class B:public A
{
public:
    C c;
    char* resource;

    B()
    {
        resource=new char[100];
        cout<<"in B constructor"<<endl;
        throw -1;
    }
    ~B()
    {
        cout<<"in B destructor"<<endl;
        delete[]  resource;
    }
};

int main()
{
    try
    {
        B b;
    }
    catch(int)
    {
        cout<<"catched"<<endl;
    }
}
 

輸出：

in A constructor
in C constructor
in B constructor
in C destructor
in A destructor
catched

從輸出結果可以看出，在建構函式中丟擲異常，當前物件的解構函式不會被呼叫，在建構函式中分配了記憶體，造成記憶體洩露，所以要格外注意。

此外，在構造物件b的時候，先要執行其直接基類A的建構函式，再執行其成員物件c的建構函式，然後再進入類B的建構函式。由於在類B的建構函式中丟擲了異常，而此異常並未在建構函式中被捕捉，所以導致類B的建構函式執行中斷，物件b並未構造完成。在類B的建構函式“回滾”的過程中，c的解構函式和類A的解構函式相繼被呼叫。最後，由於b並沒有被成功構造，所以main()函式結束時，並不會呼叫b的解構函式，也就很容易造成記憶體洩露。

建構函式異常，可以總結如下：   

1.C++中通知物件構造失敗的唯一方法那就是在建構函式中丟擲異常；   

2.建構函式丟擲異常時，解構函式將不會被執行；   

3.丟擲異常時，其子物件將被逆序析構。

使用智慧指標管理記憶體資源

使用RAII（Resource Acquisition is Initialization）技術可以避免記憶體洩漏。RAII即資源獲取即初始化，也就是說在建構函式中申請分配資源，在解構函式中釋放資源。因為C++的語言機制保證了，當一個物件建立的時候，自動呼叫建構函式，當物件超出作用域的時候會自動呼叫解構函式。所以，在RAII的指導下，我們應該使用類來管理資源，將資源和物件的生命週期繫結。智慧指標是RAII最具代表的實現，使用智慧指標，可以實現自動的記憶體管理，再也不需要擔心忘記delete造成的記憶體洩漏。

因此，當建構函式不得已丟擲異常時，可以利用“智慧指標”unique_ptr來防止記憶體洩露。參考如下程式

#include <iostream>
using namespace std;

class A
{
public:
    A() { cout << "in A constructor" << endl; }
    ~A() { cout << "in A destructor" << endl; }
};

class B
{
public:
    unique_ptr<A> pA;
    B():pA(new A)
    {
        cout << "in B constructor" << endl;
        throw - 1;
    }
    ~B()
    {
        cout << "in B destructor" << endl;
    }
};

int main()
{
    try
    {
        B b;
    }
    catch (int)
    {
        cout << "catched" << endl;
    }
}

執行結果：

in A constructor
in B constructor
in A destructor
catched

 從程式的執行結果來看，通過智慧指標對記憶體資源的管理，儘管在類B建構函式丟擲異常導致類B解構函式未被執行，但類A的解構函式仍然在物件pA生命週期結束時被呼叫，避免了資源洩漏。

解構函式中丟擲異常？在解構函式中是可以丟擲異常的，但是這樣做很危險，請儘量不要這要做。原因在《More Effective C++》中提到兩個： （1）如果解構函式丟擲異常，則異常點之後的程式不會執行，如果解構函式在異常點之後執行了某些必要的動作比如釋放某些資源，則這些動作不會執行，會造成諸如資源洩漏的問題。 （2）通常異常發生時，c++的異常處理機制在異常的傳播過程中會進行棧展開（stack-unwinding），因發生異常而逐步退出複合語句和函式定義的過程，被稱為棧展開。在棧展開的過程中就會呼叫已經在棧構造好的物件的解構函式來釋放資源，此時若其他解構函式本身也丟擲異常，則前一個異常尚未處理，又有新的異常，會造成程式崩潰。

那麼如果無法保證在解構函式中不發生異常， 該怎麼辦? 其實還是有很好辦法來解決的。那就是把異常完全封裝在解構函式內部，決不讓異常丟擲解構函式之外。這是一種非常簡單，也非常有效的方法。

~ClassName()

{
    try {
        do_something();
    }
    catch(…) {  //這裡可以什麼都不做，只是保證catch塊的程式丟擲的異常不會被扔出解構函式之外

    }

}

綜上：在建構函式和解構函式中丟擲異常會導致記憶體洩漏等問題出現。