handling failing constructors

Question

I am reading failing constructors from C++ FAQ and don't understand the following code.

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
}

How is it possible that the memory pointed to by p will not leak if the constructor throws? I assumed the sequence is as follows.

Memory is allocated for object Y.
Y's constructor is called.
Y's constructor throws and memory pointed to by p leaks.

You left out step 4, memory for p is freed. Why do you think this is not possible? — john
– john, Commented Nov 12, 2013 at 16:22
i can get that the innards of Y may apply RAII in Y's constructor but what deletes p? — goldcode
– goldcode, Commented Nov 12, 2013 at 16:27
::operator new promises to allocate memory, call the constructor and if that throws to deallocate again. Pretty easy to implement. — Hans Passant
– Hans Passant, Commented Nov 12, 2013 at 16:28
got it! so in 'exceptional' circumstances new would also call a delete. — goldcode
– goldcode, Commented Nov 12, 2013 at 16:30

Jerry Coffin · Accepted Answer · 2013-11-12 16:28:19Z

2

If Y's constructor throws, then the stack is unwound, including deleting the memory allocated for Y.

The problems arise primarily when/if you have more than one object to deal with. For example:

void f() { 
    X *x = new X();
    Y *y = new Y();
}

Now, if the new X() part succeeds, but the new Y() part fails, the memory allocated for y will be deleted, but x will not be destroyed, and its memory will be leaked. You can work around this problem with try blocks, if you really insist:

try { 
    X *x = new X();

    Y * y = new Y();
}
catch (y_construction_failed) {
    delete x;
}

The big problem with this is that you have to nest the try blocks if you have more than two items, so if you need, say, half a dozen local variables, it's going to be deeply nested and excruciatingly ugly.

answered Nov 12, 2013 at 16:28

Jerry Coffin

494k83 gold badges656 silver badges1.2k bronze badges

Sign up to request clarification or add additional context in comments.

2 Comments

goldcode Over a year ago

I'd prefer RAIIing all those objects with smart pointers. i just did not know that the new operator also kind of applies RAII.

Jerry Coffin Over a year ago

@goldcode: Yes, in most cases, you want to have each object manage itself, and eliminate all the try blocks and such.

user2249683 · Accepted Answer · 2013-11-12 16:39:20Z

0

You will run into a similar problem having a function void f(X*, Y*) and calling f(new X(), new Y()). If one of the new calls succeeds and the other fails you have a memory leak. To resolve it you might create additional functions 'X* make_X()' and 'Y* make_Y()' returning pointers. Now, f(make_X(), make_Y()) is safe. (And after going that far, you might use smart pointers)

answered Nov 12, 2013 at 16:39

user2249683

Comments

ComicSansMS · Accepted Answer · 2013-11-12 16:44:06Z

It's important to notice that even though the object is deleted, its destructor is not called in this case.

This makes sense, since an exception during construction indicates that the object was never fully constructed (ie. its class invariants have not been established), so calling the destructor could be dangerous.

The downside of this is that if the constructor performs actions that require cleanup which would normally be performed by the destructor, it is now the constructor's responsibility to perform this cleanup in case of exceptions. Take the following example:

class C {
private:
    int* p1;
    int* p2;
public:
    C() : p1(new int()), p2(new int()) {}
    ~C() { delete p1; delete p2; }
};

If the allocation p2 throws, the memory already allocated for p1 will leak. It is your responsibility as a programmer to write constructors in a way that this cannot happen.

The easiest way to achieve this is by delegating the resource management responsibilities to a RAII container class like unique_ptr. That way, no class is responsible for managing more than one resource and scenarios like the one outlined above can no longer occur.

Collectives™ on Stack Overflow

handling failing constructors

3 Answers 3

2 Comments

Comments

Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

3 Answers 3

2 Comments

Comments

Comments

Your Answer

Sign up or log in

Post as a guest

Related