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;
}
}
而且你不会有内存泄漏（默认的 dtor 也会清理动态内存分配）。
总结一下（希望这也能回答关于
base* temp = new base();
陈述）：
当在构造函数中抛出异常时，在正确处理对象的中止构造中可能发生的资源分配方面，您应该注意几件事：
这意味着如果您的对象拥有资源，您有 2 个方法可用于清理那些在构造函数抛出时可能已经获取的资源：
两个新的都将被泄露。
将堆创建对象的地址分配给命名的智能指针，以便在抛出异常时调用的智能指针析构函数中将其删除 - ( 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;
}
};
现在，当在构造函数中抛出异常时堆栈展开时，将调用psomeclass和pint析构函数，并且这些析构函数将释放分配的内存。
int main(){
base *temp = new base();
}
对于使用 (non-plcaement) new 的普通内存分配，如果构造函数抛出异常，则由 operator new 分配的内存会自动释放。至于为什么要释放单个成员（响应对 Mike B 的回答的评论），自动释放仅适用于在新分配的对象的构造函数中引发异常时，而不是在其他情况下。此外，释放的内存是为对象成员分配的内存，而不是您可能在构造函数内部分配的任何内存。即它会释放成员变量a、pint、objsomeclass和psomeclass的内存，但不会释放从new someclass()和new int()分配的内存。
我相信最佳答案是错误的，并且仍然会泄漏内存。如果构造函数抛出异常，则不会调用类成员的析构函数（因为它从未完成初始化，并且可能某些成员从未到达其构造函数调用）。它们的析构函数仅在类的析构函数调用期间被调用。这才有意义。
这个简单的程序演示了它。
#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;
}
}
祝你好运，茨维。
是的，该代码会泄漏内存。引发异常时，不会释放使用“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;
}
如果你在构造函数中抛出，你应该清理在调用 throw 之前的所有内容。如果您使用继承或抛出析构函数，您真的不应该这样做。这种行为很奇怪（没有我的标准，但它可能是未定义的？）。
您“新”的所有内容都需要删除，否则会导致内存泄漏。所以这两行：
psomeclass = new someclass();
pint = new int();
会导致内存泄漏，因为你需要这样做：
delete pint;
delete psomeclass;
在 finally 块中以避免它们被泄露。
另外，这一行：
base temp = base();
是不必要的。你只需要这样做：
base temp;
添加“= base()”是不必要的。
您需要删除 psomeclass ...不需要清理整数...