class someclass {};
class base
{
int a;
int *pint;
someclass objsomeclass;
someclass* psomeclass;
public:
base()
{
objsomeclass = someclass();
psomeclass = new someclass();
pint = new int();
throw "constructor failed";
a = 43;
}
}
int main()
{
base temp();
}
在上面的代码中，构造函数抛出异常。哪些对象将泄漏，如何避免内存泄漏？
int main()
{
base *temp = new base();
}
在上面的代码中怎么办？构造函数抛出异常后如何避免内存泄漏？
是的，它会泄露内存。当构造函数抛出异常时，没有析构函数被调用（在这种情况下，您没有展示释放动态分配对象的析构函数，但让我们假设您有一个）。这是使用智能指针的主要原因——由于智能指针是完整的对象，它们将在异常的栈展开期间调用析构函数并有机会释放内存。
如果您使用类似于Boost scoped_ptr<> 模板之类的东西，您的类可能看起来更像：
class base{
int a;
scoped_ptr<int> pint;
someclass objsomeclass;
scoped_ptr<someclass> psomeclass;
base() :
pint( new int),
objsomeclass( someclass()),
psomeclass( new someclass())
{
throw "constructor failed";
a = 43;
}
}
并且您将不会有内存泄漏（默认的析构函数也会清理动态内存分配）。
总结一下（希望这也回答了关于“
”的问题）：base* temp = new base();
构造函数中抛出异常时，需要注意如何正确处理已被分配但未完成构造对象的资源分配问题：
这意味着，如果您的对象拥有资源，则有两种方法可用于清理在构造函数抛出异常时可能已经获取的这些资源：
a 之外的所有成员不是都在执行 throw 行时被构造了吗？ - Nathan两个消息都会被泄露。
将堆创建的对象的地址分配给命名智能指针，以便在抛出异常时调用智能指针析构函数进行删除 - (RAII)。
class base {
int a;
boost::shared_ptr<int> pint;
someclass objsomeclass;
boost::shared_ptr<someclass> psomeclass;
base() :
objsomeclass( someclass() ),
boost::shared_ptr<someclass> psomeclass( new someclass() ),
boost::shared_ptr<int> pint( new int() )
{
throw "constructor failed";
a = 43;
}
};
int main(){
base *temp = new base();
}
我认为最佳答案是错误的，仍然会泄漏内存。 如果构造函数抛出异常（因为它从未完成初始化，可能有些成员从未达到其构造函数调用），则类成员的析构函数将不会被调用。 它们的析构函数仅在类的析构函数调用期间才会被调用。这是有意义的。
这个简单的程序证明了这一点。
#include <stdio.h>
class A
{
int x;
public:
A(int x) : x(x) { printf("A constructor [%d]\n", x); }
~A() { printf("A destructor [%d]\n", x); }
};
class B
{
A a1;
A a2;
public:
B()
: a1(3),
a2(5)
{
printf("B constructor\n");
throw "failed";
}
~B() { printf("B destructor\n"); }
};
int main()
{
B b;
return 0;
}
使用 g++ 4.5.2 编译器，输出如下：
A constructor [3]
A constructor [5]
B constructor
terminate called after throwing an instance of 'char const*'
Aborted
#include <stdio.h>
class A
{
int x;
public:
A(int x) : x(x) { printf("A constructor [%d]\n", x); }
~A() { printf("A destructor [%d]\n", x); }
};
class B
{
A * a1;
A * a2;
public:
B()
try // <--- Notice this change
: a1(NULL),
a2(NULL)
{
printf("B constructor\n");
a1 = new A(3);
throw "fail";
a2 = new A(5);
}
catch ( ... ) { // <--- Notice this change
printf("B Cleanup\n");
delete a2; // It's ok if it's NULL.
delete a1; // It's ok if it's NULL.
}
~B() { printf("B destructor\n"); }
};
int main()
{
B b;
return 0;
}
B constructor
A constructor [3]
B Cleanup
A destructor [3]
terminate called after throwing an instance of 'char const*'
Aborted
class C
{
std::shared_ptr<someclass> a1;
std::shared_ptr<someclass> a2;
public:
C()
{
std::shared_ptr<someclass> new_a1(new someclass());
std::shared_ptr<someclass> new_a2(new someclass());
// You will reach here only if both allocations succeeded. Exception will free them both since they were allocated as automatic variables on the stack.
a1 = new_a1;
a2 = new_a2;
}
}
祝你好运，Tzvi。
B b; 周围加上 try catch，则可以按预期调用析构函数。 - sourcenouveau如果你在构造函数中抛出异常，那么在抛出异常之前应该清除掉所有的东西。但如果你使用继承或者在析构函数中抛出异常，这其实不是一个好的做法。这种行为非常奇怪（我手头没有我的标准，但可能是未定义的？）。
是的，那段代码会泄漏内存。使用“new”分配的内存块在引发异常时不会被释放。这是RAII背后的动机之一。
为避免内存泄漏，请尝试像这样做：
psomeclass = NULL;
pint = NULL;
/* So on for any pointers you allocate */
try {
objsomeclass = someclass();
psomeclass = new someclass();
pint = new int();
throw "constructor failed";
a = 43;
}
catch (...)
{
delete psomeclass;
delete pint;
throw;
}
所有你 "new" 的东西都需要被删除，否则你会导致内存泄漏。因此，这两行代码：
psomeclass = new someclass();
pint = new int();
会导致内存泄漏，因为你需要执行以下操作：
delete pint;
delete psomeclass;
base temp = base();
是不必要的。你只需要做：
base temp;
添加“= base()”是不必要的。
你需要删除psomeclass... 清理整数不是必要的...