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

Question

Thanks for all the response.

I reformatted my question to understand the state of the member pointer after the containg class constructor throws an exception

Again my example class :)

class Foo
{
public:
    Foo()
    {
       int error = 0;
        p = new Fred;

        throw error;  // Force throw , trying to understand what will happen to p
    }

   ~Foo()
    {
       if (p)
       {
           delete p;
           p = 0;
       }
     }
private:
   Fred* p;
};

int main()
{
      try
      {
         Foo* lptr = new Foo;
      }
      catch (...)
      {}
}

The consturctor for class foo would throw an exception for some random reason. I understand that the desturctor of foo will never be called but in this case will the destructor for p get called?

what difference it makes to have p as a boost smart pointer than a raw pointer to fred.

Thanks.

It was my bad. pardon me for not properly formatting my question. I was trying to understand if the destructor of a member pointer will be called if the constructor of the container class fails for some random reason. Also what difference it makes to have p as a boost smart pointer than a raw pointer to fred. — mithuna, Aug 04 '09 at 23:39
The destructors of all members of Foo will be called if the body of Foo's constructor throws. However, the member p is a Fred*, and "destructors" of pointers never do anything (equivalently: they don't have destructors. I don't recall the exact language). So the question of whether or not it is called is moot. The destructor of Fred will not be called. If p is a shared_ptr, then it's possible for the Fred to be successfully created by `new`, and then p's constructor to throw. In that case, the destructor of class Fred will be called by the shared_ptr's constructor, as part of its contract. — Steve Jessop, Aug 04 '09 at 23:59

score 7 · Accepted Answer · edited May 23 '17 at 12:18

There is a similar question here that covers what your asking.

In this case, if the call to new fails, then the memory for the pointer is guaranteed to be freed. If the call succeeds, and the constructor throws after that, you will have a memory leak.

The destructor of the class will not be called, because the object was never fully constructed. There are two ways to fix this.

1)

Have exceptions fully managed in the constructor:

class Foo
{
public:
    Foo()
    try
    {
        p = new p;

        throw /* something */; 
    }
    catch (...)
    {
       delete p;

       throw; //rethrow. no memory leak
    }
private:
    int *p;
};

2)

Or use a smart pointer. When a constructor is entered, all of its members have been constructed. And because when a constructor throws, and objects members have been constructed, they must be destructed. And a smart pointer fixes that:

class Foo
{
public:
    Foo() :
    p(new int)
    {
        throw /* something */; 
    }
private:
    std::auto_ptr<int> p;
};

Third way around the issue is two-phase construction. First phase: regular constructor that never throws. Second phase: possibly throwing code. Construction phases are easily integrated in a static factory method. This pattern is common in e.g. Symbian C++ code. http://developer.symbian.com/main/support/code_clinic/clinic_june2008/ — laalto, Aug 05 '09 at 06:44

score 2 · Answer 2 · edited May 23 '17 at 11:55

Not if it was never allocated.

But instead of NULL being returned by bad allocations via new, you will get an exception std::bad_alloc.

NULL gets returned by C malloc if an allocation cannot be made.

You are also correct that if an object is not fully constructed, it will not be destructed. So if you have a successful allocation on the heap in a constructor, and then an exception is thrown, that will lead to a memory leak.

You could also consider having a zombie state instead of throwing an exception. Some of the standard C++ library does this. In which case the object is not in a valid state and can be checked if it is in a valid state via another method.

Generally throwing exceptions in constructors is best though.

See my answer here for an extended discussion.

score 1 · Answer 3 · answered Aug 04 '09 at 23:29

1

The destructor for p will not be called, if the memory allocation for p fails.

answered Aug 04 '09 at 23:29

Rob Knight

8,624
1
20
11

score 1 · Answer 4 · answered Aug 04 '09 at 23:30

1

The question really doesn't make any sense. new Fred(); will never return NULL. It will only ever either successfully create a Fred object, or throw an exception. If it threw an exception, the Fred object would never have existed, so it's destructor would not be called.

answered Aug 04 '09 at 23:30

Tyler McHenry

74,820
18
121
166

2

'new' can return NULL if set_new_handler(NULL) was called beforehand, or if 'new(nothrow)' is used. – Remy Lebeau Aug 04 '09 at 23:39
@RemyLebeau Calling set_new_handler(NULL) won't make it return NULL instead of throwing. According to http://www.cplusplus.com/reference/new/set_new_handler/ `If this is a null-pointer, the new-handler function is reset to none (and bad_alloc is thrown instead)` – Roman Kruglov Jul 12 '13 at 14:14
@Occulta: The Borland/CodeGear/Embarcadero compiler implements it the way I described. [See documentation](http://docwiki.embarcadero.com/RADStudio/XE4/fr/Set_new_handler_function): "To retain the traditional version of new, **which does not throw exceptions**, you can use set_new_handler(0)." – Remy Lebeau Jul 12 '13 at 14:46
@RemyLebeau that's probably non-standard. The question doesn't specify that it's about Borland dialects. – Roman Kruglov Jul 15 '13 at 09:52

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

4 Answers4

Linked

Related