Why is it undefined behavior to delete[] an array of derived objects via a base pointer?

by

Base* p = new Base[n] creates an n-sized array of Base elements, of which p then points to the first element. Base* p = new Derived[n] however, creates an n-sized array of Derived elements. p then points to the Base subobject of the first element. p does not however refer to the first element of the array, which is what a valid delete[] p expression requires.

Of course it would be possible to mandate (and then implement) that delete [] p Does The Right Thing™ in this case. But what would it take? An implementation would have to take care to somehow retrieve the element type of the array, and then morally dynamic_cast p to this type. Then it’s a matter of doing a plain delete[] like we already do.

The problem with that is that this would be needed every time an array of polymorphic element type, regardless of whether the polymorphism is used on not. In my opinion, this doesn’t fit with the C++ philosophy of not paying for what you don’t use. But worse: a polymorphic-enabled delete[] p is simply useless because p is almost useless in your question. p is a pointer to a subobject of an element and no more; it’s otherwise completely unrelated to the array. You certainly can’t do p[i] (for i > 0) with it. So it’s not unreasonable that delete[] p doesn’t work.

To sum up:

  • arrays already have plenty of legitimate uses. By not allowing arrays to behave polymorphically (either as a whole or only for delete[]) this means that arrays with a polymorphic element type are not penalized for those legitimate uses, which is in line with the philosophy of C++.

  • if on the other hand an array with polymorphic behaviour is needed, it’s possible to implement one in terms of what we have already.

More Related Contents:

  1. C++ delete – It deletes my objects but I can still access the data?
  2. Dynamic memory allocation of array in C & C++
  3. What is the strict aliasing rule?
  4. Calling delete on variable allocated on the stack
  5. Is uninitialized local variable the fastest random number generator?
  6. delete vs delete[] [duplicate]
  7. How does delete[] know it’s an array?
  8. Why doesn’t delete set the pointer to NULL?
  9. Why is out-of-bounds pointer arithmetic undefined behaviour?
  10. C++ compilation bug?
  11. Deleting a pointer to const (T const*)
  12. Why is initialization of a new variable by itself valid? [duplicate]
  13. Why would one replace default new and delete operators?
  14. Is this infinite recursion UB?
  15. Is it still safe to delete nullptr in c++0x?
  16. Is the pointer guaranteed to preserve its value after `delete` in C++?
  17. Deleting a pointer in C++
  18. Why are arguments which do not match the conversion specifier in printf undefined behavior?
  19. delete[] an array of objects
  20. Implementing a std::vector like container without undefined behavior
  21. new() without delete() is Undefined Behavior or merely Memory Leak? [duplicate]
  22. Why does printf(“%f”,0); give undefined behavior?
  23. At what point does dereferencing the null pointer become undefined behavior?
  24. Why doesn’t delete destroy anything?
  25. When a float variable goes out of the float limits, what happens?
  26. Dangling references and undefined behavior
  27. In which versions of the C++ standard does “(i+=10)+=10” have undefined behaviour?
  28. Observable behavior and undefined behavior — What happens if I don’t call a destructor?
  29. Calling delete on NULL pointers – C++03 vs C++11
  30. Fun with uninitialized variables and compiler (GCC)

Leave a Comment