Question

This is related to a question posted yesterday.

class A
{
public:
    mutable int x;
   A()  
   { 
      static int i = 0; 
      x = i; 
      i++;  
      std::cout << " A()" << std::endl; 
   }
   ~A() 
   { 
       std::cout << "~A()" << std::endl; 
   }
   void foo() const 
   { 
       x = 1; 
   };
};

class B
{
public:
   const A & a;
   B(const A & a) : a(a) 
   { 
       std::cout << " B()" << std::endl; 
   }
   ~B() 
   { 
       std::cout << "~B()" << std::endl; 
   }
   void doSomething() 
   { 
       a.foo(); 
   };
};

int main() 
{
   B b((A()));
   b.doSomething();
}

Now, a’s destructor is called before the call to doSomething. However, the call works although the function basically changes a member of A. Is it not the same instance. No other A’s are created. I used the static inside A’s constructor to keep track of that. Can anyone explain?

Answer 1

This is undefined behavior, so there is no language standard explanation.

However, the destructor of A doesn’t do anything to the memory area where x is stored, so if you look there later the value might just still be there. Or if you try to write to the address, the address is still there. You are just not allowed to do that.