How to free memory in try-catch blocks?

Question

I have a simple question hopefully - how does one free memory which was allocated in the try block when the exception occurs? Consider the following code:

try
 {         


        

Answer 1

The 'correct' answer is RAII and shared_ptr as mentioned above, but just to be complete: in your example, you could substitute

char *heap = new char [50];

with

char *stack = static_cast<char*>( alloca(50) );

alloca is almost identical to malloc, except that it alocs memory on the stack instead of the heap, so no matter how you function exits (throwing or now), the memory will be reclaimed, and no deletes or frees are necessary.

Answer 2

The general answer is use RAII.

However, its possible to solve it by moving the variable out of the try{} scope:

char * heap = NULL;
try {
  heap = new char [50];
  ... stuff ...
} catch (...) {
  if (heap) {
    delete[] heap;
    heap = NULL;
  }
  ... however you want to handle the exception: rethrow, return, etc ...
}

Please note that I'm not recommending this as a good practice - but more of a down & dirty to be used only if you really know the risks and are still willing to take them. Personally, I'd use RAII.

Peace

Answer 3

Study the RAII idiom (Resource Acquisition Is Initialization)! See e.g. the Wikipedia article on RAII.

RAII is just the general idea. It is employed e.g. in the C++ standard library's std::unique_ptr or std::shared_ptr template classes.

---

Very brief explanation of the RAII idiom:

Basically, it is the C++ version of try..finally blocks found in some other languages. The RAII idiom is arguably more flexible.

It works like this:

• You write a wrapper class around your resource (e.g. memory). The destructor is responsible for freeing the resource.

• You create, as a local (automatic) variable, an instance of your wrapper class in a scope. Once program execution leaves that scope, the object's destructor will be called, thereby releasing the resource (e.g. memory).

The important point is that it doesn't matter how the scope is exited. Even if an exception is thrown, the scope is still exited and the wrapper object's destructor is still called.

---

Very crude example:

// BEWARE: this is NOT a good implementation at all, but is supposed to
// give you a general idea of how RAII is supposed to work:
template <typename T>
class wrapper_around
{
  public:
    wrapper_around(T value)
        : _value(value)
    { }
    T operator *()
    {
        return _value;
    }
    virtual ~wrapper_around()
    {
        delete _value;  // <-- NOTE: this is incorrect in this particular case;
                        // if T is an array type, delete[] ought to be used
    }
  private:
    T _value;
};
// ...

{
    wrapper_around<char*> heap( new char[50] );
    // ... do something ...

    // no matter how the { } scope in which heap is defined is exited,
    // if heap has a destructor, it will get called when the scope is left.
    // Therefore, delegate the responsibility of managing your allocated
    // memory to the `wrapper_around` template class.
    // there are already existing implementations that are much better
    // than the above, e.g. `std::unique_ptr` and `std::shared_ptr`!
}