Is there any situation in which an object's storage might change during its lifetime?

Question

I\'ve always assumed that an object begins and ends its lifetime in the same memory location, but I\'ve recently come across a scenario where I need to be sure. Specifically

Answer 1

Specifically, I'm looking for a guarantee from the standard that no matter what optimizations the compiler performs the address an object is constructed at is the same one that it will have its destructor called from...

and that its destructor is, indeed, guaranteed to be called from that location unless the program is terminating.

The standard guarantees both for automatic variables and static variables as long as one doesn't do bad things with the objects. However, it does not guarantee either for objects allocated from the free store.

Even for automatic variables, a crafty programmer can subvert the intention through pointer manipulation and explicitly calling the destructor through a pointer.

In addition, the wrong destructor will be called when delete-ing a base class pointer when the base class does not have a virtual destructor. This will be a programming error, not the result of intention to subvert.

Example:

struct Base
{
   int b;
};

struct Derived : virtual Base
{
   float d;
};


int main()
{
   {
      Derived d1; // Not a problem.
   }

   {
      Derived d1;
      Derived* ptr = &d1;
      delete ptr;    // Bad. The programmer subverts the program.
                     // Must not use delete.
   }

   {
      Derived* d2 = new Derived; // The destructor does not get called automatically.
   }

   {
      Derived* d2 = new Derived;
      delete d2;   // OK. The proper destructor gets called.
   }

   {
      Derived* d2 = new Derived;
      Base* ptr = d2;
      delete ptr;  // Programmer error. The wrong destructor gets called.
   }
}