Division by zero works fine in virtual Destructor

Question

#include <iostream>
using namespace std;
static int i=1;
class Parent
{
public:
    virtual ~Parent(){10/i;}
};

class Child: public Parent
{
public:
    virtual ~Child(){--i;}
};

int main()
{
    Parent *ptr = new Parent;
    Parent *ptr1 = new Child;
    delete ptr;
    delete ptr1;
    //cout<<10/i;
    return 0;
}

Why virtual destructor of the Parent class not providing any runtime error? Whereas the commented part of the code throws error when uncommented.

Answer 1

I guess your compiler optimizes the code and removes the useless part, including 10/i in the base class destructor.

Try with this:

#include <iostream>
using namespace std;
static int i=1;
class Parent
{
public:
    virtual ~Parent(){int tmp = 10/i; cout << tmp; }
};

class Child: public Parent
{
public:
    virtual ~Child(){--i;}
};

int main()
{
    Parent *ptr = new Parent;
    Parent *ptr1 = new Child;
    delete ptr;
    delete ptr1;
    //cout<<10/i;
    return 0;
}

Answer 2

Regardless of the fact that there's no observable behavior, it's fairly easy for the compiler to prove that the --i statement is always followed by 10/i, which in turn means that --i cannot be called for i==1.

Since i is static to the Translation Unit, the optimizer also knows that there's no other code changing i from its initial value of 1.

Thus a modern optimizer can prove that Child::~Child isn't called either.

In turn, this means that the fourth line of main isn't reachable. This is where things can get really funny. main appears to be free of branches, but for the compiler it isn't. new may throw, which introduces two branches to this program. And since the "usual" non-exception branch provably can't be executed, the optimizer may conclude that the only reachable branches are the 2 where either new statement throws (!)

Answer 3

Undefined behavior is undefined, so anything can happen.

A statement with no side-effects is trivial for the compiler to optimize away, so it doesn't even attempt to execute what's inside the base destructor.

Having it in a cout is a different matter - did you try both?