当构造函数抛出异常时，如何释放构造函数中的内存分配？
当构造函数抛出异常时，会导致对象创建的过程中出现错误，此时需要进行内存分配的释放，以避免内存泄漏。下面是一种常见的处理方式：
- 在构造函数中进行内存分配之前，可以使用try-catch语句捕获异常，并在catch块中进行释放操作。
class MyClass {
public:
MyClass() {
try {
// 分配内存资源
ptr = new int[100];
// 执行其他构造函数的操作
// ...
} catch (...) {
// 发生异常时进行释放
delete[] ptr;
throw; // 继续抛出异常
}
}
~MyClass() {
// 析构函数中释放资源
delete[] ptr;
}
private:
int* ptr;
};- 使用智能指针进行内存管理，如C++11中的std::unique_ptr或std::shared_ptr，它们会在对象析构时自动释放所管理的内存。
class MyClass {
public:
MyClass() {
ptr = std::make_unique<int[]>(100);
// 执行其他构造函数的操作
// ...
}
// 其他成员函数
private:
std::unique_ptr<int[]> ptr;
};以上是一种处理方式，具体的释放方法还要根据实际情况和编程语言来确定。对于其他语言如Java或Python，也可以使用类似的异常处理机制和内存管理方式来释放构造函数中的内存分配。
相关·内容
2回答
假设我们有一个带有构造函数的类：
class MyClass
{
public:
MyClass()
{
//our code goes here
throw "OMG";//well, some code that throws an exception
}
};
现在，当出现异常时，正在执行堆栈展开。我还知道，如果从构造函数抛出异常，则不会调用相应对象的析构函数，因为对象一开始从未完全“创建”过。
我被这事弄糊涂了。对我来说，这意味着只有当构造函数完成时，对象才被视为“创建”。但是很明显，所有内存都是在调用构造函数之前(或之后)在某个
浏览 2提问于2012-08-23得票数 2
回答已采纳
2回答
例如，我有一个简单的代码：
class B
{
};
class A
{
B b;
public:
A()
{
throw 1;
}
};
int main()
{
A* a = 0;
try
{
a = new A;
}
catch (int)
{
}
}
构造函数A抛出异常，则不会调用析构函数。但是B的析构函数会被调用。堆中的内存将不会被分配。我的问题是这是如何内部运作的？首先是什么:构造A或者在堆中分配内存？因此，如果分配是第一个，那么如果有异常，将如何处理
浏览 3提问于2016-11-04得票数 1
回答已采纳
4回答
我和一些同事讨论了当你在一个动态分配的类中抛出一个异常时会发生什么。我知道malloc会被调用，然后是类的构造函数。构造函数永远不会返回，那么malloc会发生什么呢？
考虑以下示例：
class B
{
public:
B()
{
cout << "B::B()" << endl;
throw "B::exception";
}
~B()
{
cout << "B::~B()" << endl;
浏览 2提问于2009-08-20得票数 7
回答已采纳
1回答
动态分析发现我们的代码库中有奇怪的内存泄漏。所讨论的代码如下：
Something *p = new Something(getArgument());
函数getArgument()有时抛出的地方。当它抛出时，新分配的对象就会泄漏。这是由Visual 2015编译的(MSC++ 19.0)。
现在，当我检查规范()时，第5.3.4/8节奇怪地说：
一个新的表达式可以调用一个分配函数(3.7.4.1)来获得对象的存储。如果新表达式通过抛出异常而终止，则可以通过调用解除分配函数(3.7.4.2)来释放存储。如果分配的类型是非数组类型，则分配函数的名称是operator new，而去分配函数的名
浏览 5提问于2017-05-11得票数 9
回答已采纳
我有一个其他人写的可能不稳定的类，我必须创建这个类的对象数组。我提到了类是不稳定的，所以它有时会在默认构造函数中抛出异常。我没有访问源代码的权利，只有编译好的二进制文件。
当我使用new分配这些类型对象的动态数组时，这些坏对象中有一个可能会抛出异常。它正在抛出一个自定义异常，而不是std::bad_alloc。无论如何，我需要使程序从异常中恢复，并继续执行，尽管设置了一些错误标志和什么不是。我认为我应该delete与数组相关联的内存，以防止内存泄漏。
我的推理是，如果类抛出一个异常--构造数组中间的某个元素，则该元素将不能正确地构造，并且所有未来的元素都将被异常停止构造，但是前面的元素将被正确
浏览 0提问于2018-10-16得票数 18
回答已采纳
当类在构造过程中抛出异常时，分配的内存发生了什么?您将如何处理这样的事情。例如：
std::auto_ptr<ThirdPartyClass> au_tpc;
try
{
au_tpc.reset(new ThirdPartyClass());
}
catch(...)
{
// What happened to the memory allocated of
// sizeof(ThirdPartyClass) for the new instance?
}
浏览 3提问于2013-07-30得票数 3
回答已采纳
1回答
提到，new和delete有不同的版本。nothrow new是众所周知的--如果内存分配失败，它会返回null，而不是抛出异常。但是nothrow delete在这里提到了什么呢？
浏览 2提问于2009-12-25得票数 10
回答已采纳
在阅读C++引物+中的智能指针模板类时，我发现了这样的问题。本书举例说明了如何实现auto_ptr类，如下所示，
template<class X> class auto_ptr {
public:
explicit auto_ptr(X* p = 0) throw();
...};
在构造函数末尾抛出()意味着此构造函数不会抛出异常。我知道这是不可取的，但我不知道为什么它需要禁用其异常抛出。
浏览 4提问于2016-02-10得票数 1
3回答
因此，我们有一个构造函数，它可以根据传递给它的参数抛出异常，但是如果发生这种情况，我们不知道如何删除对象。守则的重要部分：
try
{
GameBase *gameptr = GameBase::getGame(argc, argv);
if (gameptr == 0)
{
std::cout << "Correct usage: " << argv[PROGRAM_NAME] << " " << "TicTacToe" << std::endl
浏览 6提问于2016-03-30得票数 8
回答已采纳
2回答
Exceptional C++提到了以下代码
template <class T> class Stack
{
public:
Stack();
~Stack();
/*...*/
private:
T* v_; // ptr to a memory area big
size_t vsize_; // enough for 'vsize_' T's
size_t vused_; // # of T's actually in
浏览 0提问于2011-08-05得票数 6
回答已采纳
我真不敢相信我找不到明确的答案.
在使用C++运算符初始化异常的情况下，如何释放在new类构造函数抛出异常后分配的内存。例如：
class Blah
{
public:
Blah()
{
throw "oops";
}
};
void main()
{
Blah* b = NULL;
try
{
b = new Blah();
}
catch (...)
{
// What now?
}
}
当我尝试这样做时，b在catch块中为NULL (这是有意义的)。
调试时，我注意到控制在访问构造函数之前进入内存分配例程
浏览 2提问于2009-11-04得票数 54
回答已采纳
假设有这样的代码：
class CFoo
{
public:
CFoo()
{
iBar = new CBar();
}
private:
CBar* iBar;
};
....
CFoo* foo = new CFoo();
当执行上面的代码行时，将分配第一个内存来保存CFoo对象。但是，如果新行CBar()抛出异常(由于内存不足)，系统会自动释放先前分配给CFoo对象的内存吗？我认为它必须这样做，但找不到任何明确的参考。如果不是，那么如何由编码器释放内存，因为它不会被分配给foo？
浏览 3提问于2011-01-18得票数 4
回答已采纳
6回答
我有一个关于C++中失败的构造函数和失败的析构函数的问题。
我注意到当构造函数失败时，会抛出一个异常。但是在析构函数中没有抛出异常。
我的问题是
1)如果构造函数失败，会抛出什么异常？bad_alloc？或者其他相关的东西？在什么情况下，构造函数会失败？那么成功构建的部分呢？
2)在什么情况下，析构函数会失败？如果没有抛出异常，析构函数会发生什么？编译器是如何处理它的？它被调用的函数的返回值是什么？
谢谢!
任何意见都是非常感谢的！
浏览 0提问于2010-02-27得票数 4
回答已采纳
我使用的是Borland Embarcadero的bcc32命令行编译器。考虑这个程序：
int main(int, char **)
{
try
{
std::string *a = new string(0xf0000000, ' ');
...
delete a;
}
catch(const std::bad_alloc &)
{
...
}
}
当s
浏览 0提问于2011-07-11得票数 1
回答已采纳
3回答
假设我有一个这样的类：
#include <iostream>
using namespace std;
class Boda {
private:
char *ptr;
public:
Boda() {
ptr = new char [20];
}
~Boda() {
cout << "calling ~Boda\n";
delete [] ptr;
}
voi
浏览 14提问于2010-06-28得票数 6
回答已采纳
2回答
我读了保罗·德特尔( Paul )的“如何编程”( C++ How to Program 8 Edition )一书。在第645页有一项声明：
当在新表达式中创建的对象的构造函数中抛出异常时，将释放该对象的动态分配内存。
为了验证这个语句，我编写了如下代码：
#include <iostream>
#include <exception>
#include <memory>
class A{
public:
A(){std::cout << "A is coming." << std::endl;}
浏览 7提问于2015-06-13得票数 3
回答已采纳
感谢所有的回复。
我重新设置了问题的格式，以便在包含类的构造函数抛出异常后理解成员指针的状态
又是我的示例类:)
class Foo
{
public:
Foo()
{
int error = 0;
p = new Fred;
throw error; // Force throw , trying to understand what will happen to p
}
~Foo()
{
if (p)
{
delete p;
p
浏览 2提问于2009-08-04得票数 1
回答已采纳
2回答
我看了一下的文章，上面写着
注意:如果构造函数以抛出异常结束，则与对象本身关联的内存将被清除--没有内存泄漏。例如：
void f()
{
X x; // If X::X() throws, the memory for x itself will not leak
Y* p = new Y(); // If Y::Y() throws, the memory for *p itself will not leak
}
我很难理解这一点，如果有人能澄清这一点，我将不胜感激。我尝试了下面的示例，它显示在构造函数中出现异常的情况下，不会调用析构函数。
struct someObject
{
浏览 2提问于2014-09-21得票数 3
回答已采纳
我最近需要使用，这让我感到奇怪的是，它不接受对象来增加内存压力作为参数。我猜想，因为它与运行时联系得如此紧密，所以有一些机制可以将this指针传递给方法。我的问题有三个：
如何将此指针传递给该方法？
我注意到当从静态方法调用它时不会抛出任何异常。这个案子发生了什么？
为什么其他GC方法(如GC.SupressFinalize和GC.ReRegisterForFinalize )在此方法不需要对象参数的情况下使用对象参数？
浏览 4提问于2012-01-25得票数 8
一些C++类重载了new operator，同时不应该从外部自由地调用delete。所以我保护了这个delete操作符。此外，我用noexcept现代C++关键字标记了所有类构造函数，以便编译器不会生成调用delete()的异常处理代码。但它仍然发生在编译时，由gcc！它在调用new运算符的行上显示以下错误：
error: ‘static void MyClass::operator delete(void*)’ is protected
我在Ubuntu.The上安装了gcc 5.4.0 20160609版本，同样的代码通常是在VS-2017下编译的。
请帮帮忙。如何正确保护删除？
浏览 0提问于2018-06-28得票数 0
在下面的代码中，我调用make_shared<MyClass>，MyClass的构造函数抛出异常。如果核心文件是可用的，是否有可能在gdb的帮助下找到崩溃的起源，例如:崩溃是foo()还是fun()？
#include <iostream>
#include <memory>
using namespace std;
class MyClass
{
public:
MyClass()
{
foo();
fun();
}
~MyClass
浏览 6提问于2017-03-30得票数 0
回答已采纳
来自 of new
如果第一个版本(1)未能分配存储，则抛出bad_alloc。否则，它不会抛出异常(无抛出保证)。
对我来说，这意味着这个代码
#include <new>
struct A{
A(){
throw 0;
}
};
int main(){
try{
A* a = new A;
}
catch(std::bad_alloc&){}
}
完全没问题。但是，当使用gcc (参见)编译它时，程序在抛出int后终止。
浏览 2提问于2013-07-31得票数 1
回答已采纳
1回答
当类的构造函数在堆上分配内存时，例如
class bla
{
private:
double *data;
int size;
public:
bla(int s)
{
size = s;
data = new double [size];
}
~bla()
{
delete[] data;
}
}
我有一个函数。
void f(bool huge)
{
bla *ptr
浏览 4提问于2013-11-28得票数 1
回答已采纳
所以我的问题是，我正在尝试给一个指针分配内存，this...when，它失败了。
这是我的MatrixClass定义..
class MatrixClass
{
public:
MatrixClass(int m, int n);
MatrixClass(void);
virtual ~MatrixClass(void);
double getRead(int num1, int num2) const;
double& getReadWrite(int num3, int num4);
void set(int i,int j,doub
浏览 0提问于2012-04-21得票数 0
回答已采纳
在的激励下，我相信这个问题应该有一个新的独立的题目。以下代码触发GCC 8.1.0和Clang 6.0.0编译错误，但MSVC 19.00不触发：
class X {
public:
X() /* noexcept */ { }
private:
static void operator delete(void*) { }
};
int main() {
X* x = new X{};
}
来自
如果上面描述的对象初始化的任何部分通过抛出一个异常而终止，并且可以找到一个合适的去分配函数，则调用去分配函数来释放正在构造对象的内存，然后异
浏览 0提问于2018-06-28得票数 4
3回答
tl;dr
我想做这样的事情：
foo()
{
Y* p;
try {
p = new Y();
} catch {
//fix any problem that may have occured
}
// Now I know the object was fixed during catch or simply was created successfully.
p.do_something();
// win
}
我正在创建的对象正在使用一种永恒的资源，这种资源有时并不可靠。在没有必要的预防措施的情况下尝试分配是危险的。如果它真的失败了，还有一
浏览 2提问于2014-03-13得票数 0
2回答
我知道push_back可以抛出一个bad_alloc异常，如果没有that块，那么调用析构函数是不正确的。如果有任何push_back抛出，并且它不在try块中，那么我会有内存泄漏吗？这意味着，如果我不想泄漏，就必须将每个push_back封装在try catch中吗?这种行为是否太罕见和昂贵，使得向量无法捕获异常、释放已经分配的内存并重新抛出异常？
浏览 2提问于2020-04-25得票数 2
回答已采纳
7回答
我不知道该怎么想.
我们有一个作为服务运行的组件。它在我的本地机器上运行得非常好，但是在其他一些机器上(这两台机器的内存等于2GB)，它在第二天和连续的几天内开始生成bad_alloc异常。问题是，进程的内存使用量保持在大约50 at的水平上。另一件奇怪的事情是，通过跟踪消息，我们已经本地化了要从字符串对象抛出的异常，该对象可以将不超过1-2 Kb的数据插入流中。如果有关系的话我们就用STL-端口。
现在，当您得到一个bad_alloc异常时，您会认为这是一个内存泄漏。但是all我们的手动分配被包装在一个智能指针中。另外，当整个进程只使用~50 to时，我无法理解为什么一个字符串对象缺少内存(
浏览 7提问于2010-11-22得票数 11
回答已采纳
2回答
我试图了解异常如何影响std::vector。更准确地说，当抛出内存不足异常时，我想检查向量的大小。
我的意思是这样的：
std::vector<int> v;
try {
for(unsigned int i = 0; i < desiredSize; ++i)
v.push_back(i);
}
catch (const std::bad_alloc&) {
cerr << "Out of memory! v.size() = " << v.size() << endl;
浏览 1提问于2017-05-08得票数 22
回答已采纳
为什么new在失败时不返回NULL？为什么它只在失败时抛出异常？
既然它在成功时返回一个指向对象的指针，那么为什么在失败时不返回呢？这种行为有什么特别的原因吗？
浏览 0提问于2014-10-17得票数 41
这似乎是一个相对容易的问题，但我尝试过一些事情，但我想不出如何捕捉内存中的类型异常。以下是我尝试过的几件事：
try
catch ex as exception
if ex = outOfMemoryException then
' do something here
end if
end try
try
catch ex as exception
dim check as new outOfMemoryException
if ex = check then
' do something here
end if
end try
当抛出内存不足异常时
浏览 4提问于2014-06-26得票数 1
回答已采纳
我只是想知道如何对c++中的字符串对象进行内存处理。
我有以下代码：
#include <iostream>
using namespace std;
int main() {
// your code goes here
string str = new char[30];
str = new char[60];
delete[] str;
return 0;
}
这段代码肯定会抛出错误，但是有人能详细解释一下为什么这是错误吗？上面的声明会给str分配总共90个字节吗？
提前感谢
浏览 2提问于2022-06-09得票数 -2
我知道从析构函数抛出异常是不安全的，但是从构造函数抛出异常是不安全的吗？
例如，全局声明的对象会发生什么情况？和gcc快速测试一下，我得到了一个中止，这是不是总能保证呢？您会使用什么解决方案来应对这种情况？
有没有什么情况下，构造器可以抛出异常，而不是像我们期望的那样离开。
编辑:我想我应该补充说，我正在试图了解在什么情况下我可能会获得资源泄漏。看起来明智的做法是在抛出异常之前，手动释放我们在构造过程中获得的资源。在今天之前，我从来不需要在构造函数中抛出异常，所以试着了解其中是否有任何陷阱。
也就是说这也是安全的吗？
class P{
public:
P() {
/
浏览 2提问于2009-07-29得票数 8
回答已采纳
2回答
如何释放C结构？
、、、
给定一个结构，例如
typedef struct
{
int value;
} TestStruct;
为什么下面的代码(在IPhone上运行的Objective-C类的上下文中)抛出“非对齐指针被释放”异常？
TestStruct ts = {33};
free(&ts);
注:我的超级目标是使用具有许多向量数学函数的C库，因此需要找到一些可行的方法来混合C和Objective-C
浏览 0提问于2009-01-08得票数 4
回答已采纳
1回答
我必须分析这个涉及异常的C++代码，但我不习惯分析代码应该做什么。有几件事我不明白。此外，我没有使用缓冲区数据结构的经验，也没有在C++中抛出异常的高级细节。
数据结构的最大大小是多少？
也就是说，如果Seq_Buffer是用size_ = 100生成的，那么可以存储多少个元素？
我的直觉告诉我，如果你创造一个尺寸为100的东西，它的最大尺寸将是100，但我不能肯定事实。
构造函数可以在c++中抛出异常吗？
Seq_Buffer的构造函数可以抛出异常吗？
假设这是真的，为什么不说明尝试、捕捉或抛出块就能工作呢？我以为只有这样才能得到例外
我试过寻找这两个问题，但
浏览 0提问于2017-12-07得票数 0
我在多个地方使用createBitmap()。有时，此接口会抛出OutOfMemoryError()异常。如何避免这种异常？
我正在使用下面这样的代码：
createBitamp(width, height, Config.ARGB_8888);
屏幕的width = width
屏幕的height = height
任何帮助都将不胜感激。
浏览 0提问于2011-10-19得票数 7
实际上，我使用了以下方法来确保在对象中抛出异常时正确清除缓冲区，但它需要比下面的示例多得多的代码。
class Foo
{
private:
int m_bufferSize;
char m_isNetBufferSet;
char* m_netBuffer;
setBufferSize(const int bufferSize)
{
if (!m_isNetBufferSet)
{
m_bufferSize = bufferSize;
m_netBuffer = new
浏览 2提问于2016-03-05得票数 1
回答已采纳
1回答
从和像这样的页面中，我了解到异常可能会在抛出的过程中被复制。我还了解到，此复制不能抛出任何额外的异常，否则将调用std::terminate()。这使得编写异常类变得困难，因为例如，当std::string被复制时，它可能会抛出异常。
我的问题是:为什么C++允许编译器复制异常？通过引用或指针抛出它们，并要求程序员通过引用或指针来捕获它们，而不是通过值来捕获它们，有什么缺点？
似乎一个解决方案可能是将任何非平凡的成员包装在类似于std::shared_ptr的东西中，并复制该指针而不是它持有的对象。但这样我们就失去了复制的所有潜在优势(例如，你可以在原件保持不变的情况下编辑副本)。那么为什么C
浏览 0提问于2019-11-20得票数 0
1回答
我在想，如果一个对象被动态分配，构造函数抛出一个异常，那么该对象还需要删除吗？
class Doom
{
public:
Doom() { throw 0; }
private:
int pad;
};
int main()
{
try
{
// memory is allocated for Doom but construction fails
// is the memory deallocated if construction fails here ?
Doom* doom = new Doom()
浏览 2提问于2013-12-17得票数 0
回答已采纳
我有以下函数模板：
template<typename T>
void init(std::vector<T>& v, int min, int max)
{
for(int i = min; i <= max; i++)
v.push_back(new T());
}
它将从另一个函数中使用，如下所示：
void foo()
{
std::vector v;
init(v, 10, 20);
//something else
}
如果在函数init中初始化某个类型为T的对象时抛出一些异常，会发生什么情况
在
浏览 3提问于2015-07-08得票数 0
下面是我的示例代码。基类有一个A类的指针，使用new运算符从堆中分配内存。我明确地抛出了一个异常。因为我没有在*ptr上调用delete，所以new分配的内存不会被释放。既然对象没有被完全构造，我们如何释放内存呢？ #include <iostream>
using namespace std;
class A
{
public:
A()
{
cout<<"A::ctor"<<endl;
}
~A()
{
cout<<"A::Dctor&#
浏览 16提问于2019-03-21得票数 3
抛出此异常后，引发此异常的对象是否会被抛出内存？它是马上发生的吗？
换句话说，如果我将对象添加到列表中，在某个时刻，这种情况不会再发生，并且会抛出OOM错误。此时，列表本身会发生什么变化吗？
java.lang.OutOfMemoryError: Java heap space
浏览 0提问于2012-07-06得票数 0
回答已采纳
2回答
我只想确认我对异常的理解，以及它们如何影响它们的对象。
如果我抛出一个异常，就会停止一个方法的处理，对吗？所以这样做没有任何意义
if ( some_check() ) {
throw new Exception(...);
} else {
...
}
我应该这么做
if ( some_check() ) {
throw new Exception(...);
}
rest_of_code();
另外，如果我在__construct中抛出一个异常，这会销毁对象，对吧？所以我应该做我所有的参数验证异常--直接抛出--如果对象在输入验证异常中会被破坏，那么构建对象就没
浏览 0提问于2010-03-03得票数 1
回答已采纳
有一天，我在面试中遇到了这个问题。所以只要引导我就好。
如果c++中的构造函数抛出异常，如何清理初始化的资源？
浏览 2提问于2012-10-04得票数 7
回答已采纳
3回答
我使用隐式构造函数和一个输入属性的load()成员，但也可以抛出异常。
我的问题是:如果属性是日常的C++容器，如果load()中发生异常，我会得到内存泄漏吗
感谢您的阅读。
编辑:帮助澄清我的问题的示例代码。
class One
{
public:
std::vector<int> stuff;
void load() {
stuff.resize(13);
stuff[0] = 43;
std::bad_alloc ba;
throw ba; // will this cause memory
浏览 4提问于2011-07-11得票数 1
7回答
如何修复从函数返回的内存泄漏？
例如，我创建了一个char* returnMe = new char[24324]; returnMe，它最终会从函数中返回。你如何解释这个内存泄漏？一旦它被归还，你如何销毁它？我有一些内存管理规则，可以在内存泄漏时抛出运行时错误来阻止这一点，所以我真的不能忽略它。
或者，我是不是一个笨蛋，这不是泄漏，暗示泄漏是在其他地方？
浏览 0提问于2009-10-28得票数 0
回答已采纳
5回答
C++：内存泄漏
、、
问题:在变量n的哪个值时，以下代码将导致内存泄漏？
这就是密码：
int* Bar(int n)
{
if (n == 1)
throw "exception";
return new int[n];
}
void Foo(int n)
{
int *a = Bar(n);
if (n <= 2)
return;
delete[] a;
}
，，很明显，如果n是2，就会有内存泄漏。，如果n是0，则可能会
内存泄漏(根据) )
从5.3.4/7
当直接新建声明器中的表达式的值为零时，将调用分配函数来分配没有任何元素的数组。
调自3.7
浏览 7提问于2009-07-16得票数 4
扫码
添加站长 进交流群
领取专属 10元无门槛券
手把手带您无忧上云
相关资讯
热门标签
云服务器
ICP备案
实时音视频
对象存储
即时通信 IM活动推荐
腾讯云开发者
