Exceptions: Freeing Objects in Exceptions

 

The latest version of this topic can be found at Exceptions: Freeing Objects in Exceptions.

This article explains the need and the method of freeing objects when an exception occurs. Topics include:

• Handling the exception locally

• Throwing exceptions after destroying objects

Exceptions thrown by the framework or by your application interrupt normal program flow. Thus, it is very important to keep close track of objects so that you can properly dispose of them in case an exception is thrown.

There are two primary methods to do this.

• Handle exceptions locally using the try and catch keywords, then destroy all objects with one statement.

• Destroy any object in the catch block before throwing the exception outside the block for further handling.

These two approaches are illustrated below as solutions to the following problematic example:

   void SomeFunc()        // Problematic code
   {
      CPerson* myPerson = new CPerson;

      // Do something that might throw an exception.
      myPerson->SomeFunc();

      // Now destroy the object before exiting.
      // If SomeFunc above throws an exception this code will
      // not be reached and myPerson will not be deleted.
      delete myPerson;
   }

As written above, myPerson will not be deleted if an exception is thrown by SomeFunc. Execution jumps directly to the next outer exception handler, bypassing the normal function exit and the code that deletes the object. The pointer to the object goes out of scope when the exception leaves the function, and the memory occupied by the object will never be recovered as long as the program is running. This is a memory leak; it would be detected by using the memory diagnostics.

Handling the Exception Locally

The try/catch paradigm provides a defensive programming method for avoiding memory leaks and ensuring that your objects are destroyed when exceptions occur. For instance, the example shown earlier in this article could be rewritten as follows:

   void SomeFunc()
   {
      CPerson* myPerson = new CPerson;

      try
      {
         // Do something that might throw an exception.
         myPerson->SomeFunc();
      }
      catch( CException* e )
      {
         // Handle the exception locally
         e->Delete();
      }

      // Now destroy the object before exiting.
      delete myPerson;
   }

This new example sets up an exception handler to catch the exception and handle it locally. It then exits the function normally and destroys the object. The important aspect of this example is that a context to catch the exception is established with the try/catch blocks. Without a local exception frame, the function would never know that an exception had been thrown and would not have the chance to exit normally and destroy the object.

Throwing Exceptions After Destroying Objects

Another way to handle exceptions is to pass them on to the next outer exception-handling context. In your catch block, you can do some cleanup of your locally allocated objects and then throw the exception on for further processing.

The throwing function may or may not need to deallocate heap objects. If the function always deallocates the heap object before returning in the normal case, then the function should also deallocate the heap object before throwing the exception. On the other hand, if the function does not normally deallocate the object before returning in the normal case, then you must decide on a case-by-case basis whether the heap object should be deallocated.

The following example shows how locally allocated objects can be cleaned up:

   void SomeFunc()
   {
      CPerson* myPerson = new CPerson;

      try
      {
         // Do something that might throw an exception.
         myPerson->SomeFunc();
      }
      catch( CException* e )
      {
         e->ReportError();
          // Destroy the object before passing exception on.
         delete myPerson;
         // Throw the exception to the next handler.
         throw;
      }

      // On normal exits, destroy the object.
      delete myPerson;
   }

The exception mechanism automatically deallocates frame objects; the destructor of the frame object is also called.

If you call functions that can throw exceptions, you can use try/catch blocks to make sure that you catch the exceptions and have a chance to destroy any objects you have created. In particular, be aware that many MFC functions can throw exceptions.

For more information, see Exceptions: Catching and Deleting Exceptions.

See Also

Exception Handling