Question

Question

What does the C++ standard guarantee about the state of an object in the time
after a derived class’s destructor executes, but before the base class’s destructor executes ? (This is the time when the derived class’s subobjects’ destructors are being called.)

Example

#include <string>
struct Base;

struct Member {
  Member(Base *b);
  ~Member();
  Base *b_;
};

struct Base {
  virtual void f() {}
  virtual ~Base() {}
};

struct Derived : Base {
  Derived() : m(this) {}
  virtual ~Derived() {}  
  virtual void f() {}
  std::string s; 
  Member m;
};

Member::Member(Base *b) : b_(b) {}
Member::~Member() {
  // At this point, ~Derived has finished -- can we use b_ as a 
  // Derived* object (i.e. call Derived::f or access Derived::s)?
  b_->f();
}

int main() {
  Base *bd = new Derived;
  delete bd;
}

In this example, a Member object has a pointer to a Derived object that owns it, and it attempts to access that Derived object as it is destructed…even though the destructor for Derived has already finished.

Which version of *bd‘s virtual functions would be called if some subobject called a virtual function after ~Derived() executes, but before ~Base() executes? Is it even legal to access *bd when it’s in that state?

Answer 1

from n3290 [class.cdtor]

12.7 Construction and destruction
1 For an object with a non-trivial constructor, referring to any non-static member or base class of the object before the constructor begins execution results in undefined behavior. For an object with a non-trivial destructor, referring to any non-static member or base class of the object after the destructor finishes execution results in undefined behavior.