What happens to the memory allocated by `new` if the constructor throws?

Question

Will this code cause a memory leak?

#include <stdexept>

class MyClass
{
public:
    MyClass()
    {
        throw std::runtime_error("Test");
    }
};

int main()
{
    try
    {
        MyClass * myClass = new MyClass;
    }
    catch (const std::exception & exc)
    {
        // Memory leak?
    }
    return 0;
}

The memory allocated by new is never deleted. Is this taken care of internally, or it an actual memory leak?

score 18 · Accepted Answer · answered Nov 04 '10 at 08:49

The memory will be automatically freed before the exception propagates.

This is essential, because a) the program never receives a pointer to free, and b) even if it did, it would have no portable way to actually free it since the memory never became an object that you can delete.

score 13 · Answer 2 · edited May 23 '17 at 10:33

The memory will be properly deallocated.

Related questions at SO.

Is it ever not safe to throw an exception in a constructor?

C++ : handle resources if constructors may throw exceptions (Reference to FAQ 17.4)

prasoon@prasoon-desktop ~ $ cat noleak.cpp && g++ noleak.cpp && valgrind --leak-check=full ./a.out
#include <stdexcept>

class MyClass
{
public:
    MyClass()
    {
        throw std::runtime_error("Test");
    }
};

int main()
{
    try
    {
        MyClass * myClass = new MyClass;
    }
    catch (const std::exception & exc)
    {
        // Memory leak?
    }
    return 0;
}
==3652== Memcheck, a memory error detector
==3652== Copyright (C) 2002-2009, and GNU GPL'd, by Julian Seward et al.
==3652== Using Valgrind-3.5.0 and LibVEX; rerun with -h for copyright info
==3652== Command: ./a.out
==3652== 
==3652== 
==3652== HEAP SUMMARY:
==3652==     in use at exit: 0 bytes in 0 blocks
==3652==   total heap usage: 3 allocs, 3 frees, 106 bytes allocated
==3652== 
==3652== All heap blocks were freed -- no leaks are possible
==3652== 
==3652== For counts of detected and suppressed errors, rerun with: -v
==3652== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 17 from 6)
prasoon@prasoon-desktop ~ $

score 7 · Answer 3 · answered Nov 04 '10 at 10:21

$15.2/2 - "An object that is partially constructed or partially destroyed will have destructors executed for all of its fully constructed base classes and non-variant members, that is, for subobjects for which the principal constructor (12.6.2) has completed execution and the destructor has not yet begun execution. Similarly, if the non-delegating constructor for an object has completed execution and a delegating constructor for that object exits with an exception, the object’s destructor will be invoked. If the object was allocated in a new-expression, the matching deallocation function (3.7.4.2, 5.3.4, 12.5), if any, is called to free the storage occupied by the object."

What happens to the memory allocated by `new` if the constructor throws?

3 Answers3

Linked

Related