CODEWITHSUNDEEP
c++
jiafu
jiafu

Reputation: 6546

If the memory allocated be freed after constructor throw exception

I know Object *pObject=new Object contain two steps:

  1. operator new to allocate memory
  2. call object's constructor.

and call delete pObject:

  1. call object's destruct;
  2. operator delete to free memory.

But when new Object process, if the step 2 throw exception, if the operator delete be called to free memory by system?

Upvotes: 0

Views: 407

Answers (2)

Cramer
Cramer

Reputation: 1795

No, the destructor is not called. As the object isn't constructed properly it would be unsafe to call the destructor. However if any member objects have been constructed fully then they are destructed (as the object is complete).

Some people recommend against throwing in constructors, I believe it is better than zombie states which is akin to error codes and makes verbose code. So long as you follow RAII you should be fine (each resource is managed by it's own object). Before you throw in the constructor make sure that you clean up anything you've half done, but again, if you're using RAII that should be nothing.

The following outputs "B":

#include <iostream>

struct B {
  ~B() { std::cout << "B" << std::endl; }
};

struct A {
  A() : b() { throw(1); }
  ~A() { std::cout << "A" << std::endl; }
  B b;
};

int main() {
  try {
    A *a = new A;
    delete a;
  } catch(int a) {}
}

Edit: The above isn't what you asked, yes the delete operator is called, http://www.cplusplus.com/reference/new/operator%20delete[] says:

"These deallocation functions are called by delete-expressions and by new-expressions to deallocate memory after destructing (or failing to construct) objects with dynamic storage duration."

This could be tested by overriding the operator delete.

Upvotes: 1

nicky_zs
nicky_zs

Reputation: 3773

Yes, the operator delete will be called to release the memory allocated.

The program below can prove that:

#include <iostream>

using std::cout;
using std::endl;

class A { 
public:
    A() { cout << "A() at " << this << endl; throw 1; }
    ~A() { cout << "~A() at " << this << endl; }
};

int main(int argc, char *argv[]) {
    int N = 3;
    for (int i = 0; i < N; ++i) {
        try {
            new A;
        } catch (int a) {
            // pass
        }   
    }   
    return 0;
}

Running this program on my system, I find that the result printed out are like this:

A() at 0x2170010
A() at 0x2170010
A() at 0x2170010

Obviously, the destructors are NOT call because NO

~A() at 0x2170010

lines are printed out.

And the operator delete are surely called because the addresses of the three objects are exactly the same.

Upvotes: 0

Related Questions