C++ 构造函数抛出异常会引起内存泄漏吗?

C++ 构造函数抛出异常会引起内存泄漏吗?

 

我们用实际代码说明问题：先看一下如下代码：
#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. new一个对象有两个过程：

A.向系统申请内存空间  

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

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

3.对象在构造函数抛出异常后，系统会负责清理构造对象时申请的内存，但不会调用对象析构函数。

 

也就是说构造对象的内存会被释放掉，已经完成实例化的成员对象也会成功析构。

通过valgrind工具可以看到不存在内存泄漏。

 

 

下面我们把代码修改一下。修改只有两处，注意红色标记。

#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

 

是的，这个结果想必大家已经预料到了，析构和释放内存的操作都没有执行。

 

valgrind 的执行结果：

 

发生了内存泄漏。

 

重载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没有析构(因为inner2是一个指针，清栈的时候只会调用栈里的局部对象的析构函数，但是不会delete调用栈里指针)，想必大家也可以预见到这样的情况。

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

 

 

 

可以得到如下结论：

一个对象在构造函数中抛出异常，对象本身的内存会被成功释放，但是其析构函数不会被调用。其内部局部成员对象清栈时是会被释放掉的，故其析构函数被调用，但是用户在构造函数中动态生成的对象没有被delete掉（new出来的是一个指针，清栈时是不会delete掉栈里的指针）。

如果一个对象在构造函数中打开很多系统资源，但是构造函数中后续代码抛出了异常，则这些资源将不会被释放，建议在构造函数中加入try catch语句，对先前申请的资源进行释放后（也就是做析构函数该做的事情）再次抛出异常，确保内存和其他资源被成功回收。