Question

I have the following program where i am calling exit() in the destructor. When i create an object of type sample inside main() destructor is called once and program exits normally. But when i create a global object of type sample, “Destructing..” gets printed infinitely. Can anyone please explain how?

#include "iostream"
#include "conio.h"

using namespace std;

class sample
{
      public:
     ~sample() {
                    cout <<"Destructing.."<<endl;
                    exit(0);
                }
};

sample obj;

int main()
{
 getch();   
}

Answer 1

What’s happening is, the exit() function is getting the program to call destructors on all of the global objects. And since at the point where your class’s destructor calls exit(1); the object is not yet considered to be destructed, the destructor gets called again, resulting in an infinite loop.

You could get away with this:

class sample {
    bool exiting;
public:
    sample() { exiting = false; }
    ~sample() {
        cout << "Destructing.." << endl;
        if(exiting) return;
        exiting = true;
        exit(0);
    }
};

But having a destructor call exit() is a Bad Idea. consider one of these alternatives:

• create a separate normal (non-destructor) method for exiting
• create a function that runs until the “program” is finished and call it from main()
• use abort() instead of exit() (Thanks goldilocks for mentioning this one). abort() bypasses all of the cleaning up that is normally done when exit() is called and when main() returns. However this is not necessarily a good idea either, as certain cleanup operations in your program could be quite critical. abort() is meant only for errors that are already so bad that bypassing cleanup is warranted.

I suggested exceptions before but remembered about throwing exceptions from inside destructors and changed my mind. here’s why.

Note also, the behavior is not consistent – some compilers/environments result in an infinite loop, some don’t. It comes down to at which point in the destructor the object is considered to be destroyed. I would guess the standard either doesn’t cover this or says the behavior in this case is undefined.