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.一个对象的生成有两个过程:
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没办法成功析构,想必大家也可以预见到这样的情况。
valgrind的输出:4个字节内存泄漏,肯定是inner2没有成功释放。
可以得到如下结论:
一个对象在构造函数中抛出异常,对象本身的内存会被成功释放,但是其析构函数不会被调用,其内部成员变量都可以成功析构,但是用户在构造函数中动态生成的对象无法成功释放(这也在情理之中)。
如果一个对象在构造函数中打开很多系统资源,但是构造函数中后续代码抛出了异常,则这些资源将不会被释放,建议在构造函数中加入try catch语句,对先前申请的资源进行释放后(也就是做析构函数该做的事情)再次抛出异常,确保内存和其他资源被成功回收。