构造函数可以抛出异常、析构函数不可也不能抛出异常

一、构造函数可以抛出异常

#include <iostream>
using namespace std;
class Inner
{
public:

Inner()

{

cout<<"Inner()/n";

}

~Inner()
{
cout<<"~Inner()/n";

}

};
class Outer

{

private:

int m_Value;

Inner inner1;

public:

Outer(int value):m_Value(value)

{

cout<<"Outer(int value)/n";

throw 3;//这里抛出异常

}

~Outer()

{

cout<<"~Outer()/n";

}

void* operator new(size_t size)

{

cout<<"void* operator new(size_t size)/n";

unsigned char* tmp = ::new unsigned char[size];

return tmp;

}

void operator delete(void* ptr)

{

cout<<"void* operator delete(void* ptr)/n";

::delete[] (unsigned char*)ptr;

}

};

 

main()

{

try

{

Outer* d = new Outer(1);

}

catch(...)

{

cout<<"exception got it/n";

}

}
//这段代码编译后执行结果：
void* operator new(size_t size)

Inner()

Outer(int value)

~Inner()

void* operator delete(void* ptr)

exception got it

有异常抛出。
从代码执行结果来看，我们可以得出如下结论：
也就是说构造对象的内存会被释放掉，已经完成实例化的成员对象也会成功析构。

1.一个对象的生成有两个过程：

A.向系统申请内存空间

B.在申请的内存空间上执行构造函数，初始化对象。

2.内部对象构造先于对象本身。

3.对象在构造函数抛出异常后，系统会负责清理构造对象时申请的内存，但不会调用对象析构函数。
上面没有内存泄漏，因为throw 之前构造的对象或者其成员都已经被析构或者释放，所以throw的位置很重要，但是如果是在构造对象的过程中抛出异常，因为不会调用本对象的析构函数，所以得不到释放，就会出现内存泄漏，如下面的就会有内存泄漏：
下面我们把代码修改一下。修改只有两处，注意throw。

#include <iostream>

using namespace std;

class Inner

{

private:

int m_Value;

public:

Inner()

{

cout<<"Inner()/n";

}

Inner(int value):m_Value(value)

{

cout<<"Inner(int value)/n";

}

~Inner()

{

cout<<"~Inner()/n";

}

};

 

class Outer

{

private:

int m_Value;

Inner inner1;

public:

Outer()

{

cout<<"Outer()/n";

//throw 3;

}

Outer(int value):m_Value(value)

{

cout<<"Outer(int value)/n";

}

~Outer()

{

cout<<"~Outer()/n";

}

void* operator new(size_t size)

{

cout<<"void* operator new(size_t size)/n";

unsigned char* tmp = ::new unsigned char[size];

throw 1;  
//这里抛出异常
return tmp;}
void operator delete(void* ptr)
{cout<<"void* operator delete(void* ptr)/n";
::delete [] (unsigned char*)ptr;}};
 main()
 {
 try
 {
 Outer* d = new Outer(1);
 }
 catch(...)
 {cout<<"got it/n";}}

//我们改在重载的new操作符方法中抛出异常。
//程序输出结果：
void* operator new(size_t size)
got it
//是的，这个结果想必大家已经预料到了，异构和释放内存的操作都没有执行。
//重载new操作符，用户可以在自己的内存池中分配内存去构造对象，但是如果成功申请内存但后续执行抛出异常后，就会造成内存泄漏。
//最后修改一下代码，还是在构造函数中抛出异常，注意红色标记
#include <iostream>

using namespace std;

class Inner

{

private:

int m_Value;

public:

Inner()

{

m_Value=1;

cout<<"Inner()/n";

}

Inner(int value):m_Value(value)

{

cout<<"Inner(int value)/n";

}

~Inner()

{

cout<<"~Inner"<<m_Value<<"()/n";

}

};

 

class Outer

{

private:

int m_Value;

Inner inner1;

Inner* inner2;

public:

Outer()

{

cout<<"Outer()/n";

}

Outer(int value):m_Value(value)

{

cout<<"Outer(int value)/n";

inner2 = new Inner(2);

throw 1;
//这里抛出异常
}
~Outer()
{cout<<"~Outer()/n";}
void* operator new(size_t size)
{
cout<<"void* operator new(size_t size)/n";
unsigned char* tmp = ::new unsigned char[size];
return tmp;
}
void operator delete(void* ptr)
{
cout<<"void* operator delete(void* ptr)/n";
::delete [] (unsigned char*)ptr;}};
 main()
 {
 try{Outer* d = new Outer(1);
 }catch(...)
 {cout<<"got it/n";}}
 //代码执行结果：
 void* operator new(size_t size)
 Inner()
 Outer(int value)Inner(int value)
 ~Inner1()
 void* operator delete(void* ptr)
 got it

可以看到内部成员变量inner1成功析构，单inner2没办法成功析构，想必大家也可以预见到这样的情况。


4个字节内存泄漏，肯定是inner2没有成功释放。


可以得到如下结论：


一个对象在构造函数中抛出异常，对象本身的内存会被成功释放，但是其析构函数不会被调用，其内部成员变量都可以成功析构，
但是用户在构造函数中动态生成的对象无法成功释放（这也在情理之中）。


如果一个对象在构造函数中打开很多系统资源，但是构造函数中后续代码抛出了异常，则这些资源将不会被释放，
建议在构造函数中加入try catch语句，对先前申请的资源进行释放后（也就是做析构函数该做的事情）再次抛出异常，确保内存和其他资源被成功回收。
二、析构函数不能 也不应该抛出异常
1. more effective c++提出两点理由（析构函数不能抛出异常的理由）：
1）如果析构函数抛出异常，则异常点之后的程序不会执行，如果析构函数在异常点之后执行了某些必要的动作比如释放某些资源，
则这些动作不会执行，会造成诸如资源泄漏的问题。
2）通常异常发生时，c++的机制会调用已经构造对象的析构函数来释放资源，此时若析构函数本身也抛出异常，则前一个异常尚未处理，
又有新的异常，会造成程序崩溃的问题。
2. 那么当无法保证在析构函数中不发生异常时， 该怎么办?
其实还是有很好办法来解决的。那就是把异常完全封装在析构函数内部，决不让异常抛出函数之外。这是一种非常简单，也非常有效的方法。  

~ClassName()
{
  try{
      do_something();
  }
  catch(){  //这里可以什么都不做，只是保证catch块的程序抛出的异常不会被扔出析构函数之外。
   }
}
3. 析构函数中抛出异常时概括性总结
1）C++中析构函数的执行不应该抛出异常；
2）假如析构函数中抛出了异常，那么你的系统将变得非常危险，也许很长时间什么错误也不会发生；但也许你的系统有时就会莫名奇妙地崩溃而退出了，而且什么迹象也没有，崩得你满地找牙也很难发现问题究竟出现在什么地方；
3）当在某一个析构函数中会有一些可能（哪怕是一点点可能）发生异常时，那么就必须要把这种可能发生的异常完全封装在析构函数内部，决不能让它抛出函数之外；
4）一定要切记上面这几条总结，析构函数中抛出异常导致程序不明原因的崩溃是许多系统的致命内伤！