2021-04-15

最新推荐文章于 2022-10-30 19:33:12 发布

转载最新推荐文章于 2022-10-30 19:33:12 发布 · 117 阅读

0 ·

本内容遵循CC 4.0 BY-SA版权协议

原文链接：https://blog.csdn.net/nodeathphoenix/article/details/17252465

标签

#内存泄漏

C++ 专栏收录该内容

3 篇文章

订阅专栏

本文探讨了C++中在构造函数和析构函数中抛出异常的情况。当构造函数抛出异常时，已分配的内存会自动释放，但析构函数不会被调用。而在重载的new操作符中抛出异常会导致内存无法正确释放，造成内存泄漏。最后的例子展示了在构造函数中动态分配内存并抛出异常时，动态对象不会被删除，可能导致资源泄露。因此，建议在构造函数中进行资源管理，并在异常发生前释放已分配的资源。

提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档

一、c++析构函数中抛出异常

（1）下面是简单构造函数抛出异常：

#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工具可以看到不存在内存泄漏。
Alt

（2）第二次修改

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



#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

转载自

总结

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

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