Why is deleting an array of derived objects with a base pointer considered Undefined Behavior in C ?

Why is it Undefined Behavior to Delete[] an Array of Derived Objects with a Base Pointer?

The C Standard's 5.3.5 [expr.delete] states that in the case of "delete array," undefined behavior occurs if the dynamic type of the object to be deleted differs from its static type. This means that the following code snippet invokes undefined behavior:

<code class="cpp">struct B {
  virtual ~B() {}
};
struct D : B {};

B* p = new D[20];
delete [] p; // undefined behavior</code>

Rationale for Undefined Behavior

A "delete []" operation requires a pointer to the first element of an array. However, when using a base pointer to an array of derived objects, the pointer actually refers to the base subobject of the first element. Therefore, the "delete []" operation would be attempting to delete the base subobject instead of the first element of the array, which is incorrect.

Enforcing correct behavior in this case would involve retrieving the element type of the array and performing a dynamic_cast to that type. However, this would introduce unnecessary overhead for every polymorphic array, even when polymorphism is not used.

Additionally, the pointer "p" itself is of limited use since it only points to a base subobject. Common array operations such as "p[i]" (for i > 0) would not be possible.

Conclusion

The undefined behavior for "delete []" with a base pointer to an array of derived objects is a conscious design decision that:

• Maintains efficiency for legitimate uses of arrays
• Allows for the implementation of polymorphic arrays if desired
• Prevents incorrect array operations with derived pointers

The above is the detailed content of Why is deleting an array of derived objects with a base pointer considered Undefined Behavior in C ?. For more information, please follow other related articles on the PHP Chinese website!