Smartpointers and throwing an exception from the constructor

[Cucumber]

This has bugged me for some time now, and I havent have the time to discuss it before, so guys please tell me what you think.

We all know we can use smart pointers in C++ to take charge of automatic deallocation of objects created in the heap, we know the smart pointer will save the address allocated with "new", and that smart pointers will call "delete" when going out of scope:

   ...
  SmartPointer< Foo > foo = new Foo();
  ...
  }//<--- Automatic deallocation
 

So far so good.

But what if a constructor of class Foo throws an exception?
Will a memory allocation take place? If so, the exception will keep the smart pointer from receiving the newly allocated pointer, so when the smart pointer goes out of scope, the allocated memory wont get deleted!

What is the best way to avoid leaking memory in this case?

[weaknessforcats]

But what if a constructor of class Foo throws an exception?
Will a memory allocation take place? If so, the exception will keep the smart pointer from receiving the newly allocated pointer, so when the smart pointer goes out of scope, the allocated memory wont get deleted!

What is the best way to avoid leaking memory in this case?

Let's see, your concern is that that new operator will throw a bad_alloc and never return to assign the address to the smart pointer.

I presume you would:

SmartPointer<Foo> foo;
try
{
  foo = new Foo();
}catch (exception whoops)
{
     //necessary handling.
}
 

In this scenario, foo is created with no object. Hence the managed pointer is null. No problem. Smart pointers can be unattached to an object.

In the above code, the assignment occurs only if new returns.

Otherwise, foo remains unattached. When it goes out of scope it will be deleted normally.

Check out the article on Handle Classes in the C/C++ Articles forum.

[Cucumber]

Let's see, your concern is that that new operator will throw a bad_alloc and never return to assign the address to the smart pointer.

Actually my concern is: what if the constructor throws an exception, Im not talking about bad_alloc. I am referring to a case where the memory is allocated succesfully but the constructor throws an exception.

class Foo
{
   public: Foo( )
    {
     if ( somethingTerriblyWrongHappens )
           throw someException();
    }
}
 

[Banfa]

Subscribing .

[weaknessforcats]

Actually my concern is: what if the constructor throws an exception, Im not talking about bad_alloc. I am referring to a case where the memory is allocated succesfully but the constructor throws an exception.

Same procedure:

Foo* fptr;
try
{
  fptr= new Foo();
}catch (exception whoops)
{
     //necessary handling.
     //consider abortin your program
    //or maybe set fptr to zero.
}
 

In any case, remember that when an exception is thrown inside a constructor, all of the constructors of the data members have already been called. Therefore, before you get your catch block, the destructors on all those data members have been called and the object itself has been deleted from memory.

All that you may have to do is delete any allocations you made in your constructor since the destructor of the object being built will not be called. Also, if you use an initializer list, you may need a function try block so you can catch any exceptions thrown by the code called in the initializer list.

[Cucumber]

Same procedure:

Foo* fptr;
try
{
  fptr= new Foo();
}catch (exception whoops)
{
     //necessary handling.
     //consider abortin your program
    //or maybe set fptr to zero.
}
 

In any case, remember that when an exception is thrown inside a constructor, all of the constructors of the data members have already been called. Therefore, before you get your catch block, the destructors on all those data members have been called and the object itself has been deleted from memory.

All that you may have to do is delete any allocations you made in your constructor since the destructor of the object being built will not be called. Also, if you use an initializer list, you may need a function try block so you can catch any exceptions thrown by the code called in the initializer list.

Excelent answer, time to do some code testing.

[weaknessforcats]

All that you may have to do is delete any allocations you made in your constructor since the destructor of the object being built will not be called.

To do this you would put a try/catch block inside the construcor so you could catch any exceptions that are thrown. Inside the catch block (you are still inside the constructor) you clean up any allocations you made in the constructor and then re-throw the exception.

A function try block is a different thing:

MyClass::MyClass(int a, int b)
try
      : mymember(a,b);     //in case this throws.
{
     //this is the normal constructor
}
catch (etc...)
{
    //this is the catch for the exception in the initializer list
}
 

I didn't know if I was clear on this.