deleting an array of objects and undefined behaviour

I have just come across something I didn't know from the std:

When deleting an array, the dynamic and the static type of the object
must be the same, or the behavior is undefined (C++ Standard 5.3.5/3).

I was amazed to discover this. It was revealed to me in a test
question where it had a code fragment and said "what, if anything, is
wrong with this code?". Here is the code:

struct X {
  virtual ~X() {}
};

class Y : public X {
};

int main() {
  X* p = new Y[2];
  delete [] p;
  return 0;
}

The above code has undefined behaviour according to the std. But why?
I really don't understand. The usual gotcha when doing polymorphic
deletes is forgetting to make the dtor of the base class virtual but
that has been done here and it's still undefined behaviour!

If one wanted an array of base class pointers then how would one
delete the objects when the time comes? Would it be ok to have a
vector of boost::shared_ptrs? Or would that boil down to the above and
thus yield undefined behaviour also? I am worried if the answer to
that is "yes" because I have written such code recently. I hope it
would be ok since the container is a vector rather than a native
array. Perhaps it is native arrays that are the source of the trouble
for reasons I don't understand.

I hope that somehone who is a real whizz with the std can explain this
to me please.

Regards,

Andrew Marlow

--
      [ See http://www.gotw.ca/resources/clcm.htm for info about ]
      [ comp.lang.c++.moderated. First time posters: Do this! ]