Virtual destructor and undefined behavior

by

when/why should I use a virtual destructor?
Follow Herb Sutters guideline:

A base class destructor should be either public and virtual, or protected and nonvirtual

Can this be classified as an undefined behavior (we are aware that ~D() is not going to be called for sure) ?

It is Undefined Behavior as per the standard, which usually results in the Derived class destructor not being called and resulting in a memory leak, but it is irrelevant to speculate on after effetcs of an Undefined Behavior because standard doesn’t gaurantee anything in this regard.

C++03 Standard: 5.3.5 Delete

5.3.5/1:

The delete-expression operator destroys a most derived object (1.8) or array created by a new-expression.
delete-expression:
::opt delete cast-expression
::opt delete [ ] cast-expression

5.3.5/3:

In the first alternative (delete object), if the static type of the operand is different from its dynamic type, the static type shall be a base class of the operand’s dynamic type and the static type shall have a virtual destructor or the behavior is undefined. In the second alternative (delete array) if the dynamic type of the object to be deleted differs from its static type, the behavior is undefined.73)

What if ~D() is empty. Will it affect the code in any way ?
Still it is Undefined Behavior as per the standard, The derived class destructor being empty may just make your program work normally but that is again implementation defined aspect of an particular implementation, technically, it is still an Undefined Behavior.

Note that there is no gaurantee here that not making the derived class destructor virtual just does not result in call to derived class destructor and this assumption is incorrect. As per the Standard all bets are off once you are crossed over in Undefined Behavior land.

Note what he standard says about Undefined Behavior.

The C++03 Standard: 1.3.12 undefined behavior [defns.undefined]

behavior, such as might arise upon use of an erroneous program construct or erroneous data, for which this International Standard imposes no requirements. Undefined behavior may also be expected when this International Standard omits the description of any explicit definition of behavior. [Note: permissible undefined behavior ranges from ignoring the situation completely with unpredictable results, to behaving during
translation or program execution in a documented manner characteristic of the environment (with or without the issuance of a diagnostic message), to terminating a translation or execution (with the issuance of a diagnostic message). Many erroneous program constructs do not engender undefined behavior; they are required to be diagnosed. ]

If only derived destructor will be not called is governed by the bold text in the above quote, which is clearly left open for each implementation.

More Related Contents:

  1. Has C++ standard changed with respect to the use of indeterminate values and undefined behavior in C++14?
  2. Why is unsigned integer overflow defined behavior but signed integer overflow isn’t?
  3. Do I need to cast to unsigned char before calling toupper(), tolower(), et al.?
  4. May I treat a 2D array as a contiguous 1D array?
  5. Why does left shift operation invoke Undefined Behaviour when the left side operand has negative value?
  6. Undefined behavior and sequence points reloaded
  7. Why do constant expressions have an exclusion for undefined behavior?
  8. How is a variable at the same address producing 2 different values? [duplicate]
  9. Why dereferencing a null pointer is undefined behaviour?
  10. Why should I not try to use “this” value after “delete this”?
  11. C++ compilation bug?
  12. Why should I declare a virtual destructor for an abstract class in C++?
  13. Is this infinite recursion UB?
  14. Does not evaluating the expression to which sizeof is applied make it legal to dereference a null or invalid pointer inside sizeof in C++?
  15. Is reading an indeterminate value undefined behavior?
  16. In C++11, does `i += ++i + 1` exhibit undefined behavior?
  17. Why are arguments which do not match the conversion specifier in printf undefined behavior?
  18. Arithmetic right shift gives bogus result?
  19. Is pointer comparison undefined or unspecified behavior in C++?
  20. Why is the phrase: “undefined behavior means the compiler can do anything it wants” true?
  21. Near constant time rotate that does not violate the standards
  22. Are pointer variables just integers with some operators or are they “symbolic”?
  23. Are virtual destructors inherited?
  24. Undefined behavior causing time travel
  25. The behaviour of floating point division by zero
  26. Why doesn’t vector::clear remove elements from a vector?
  27. Is there a platform or situation where dereferencing (but not using) a null pointer to make a null reference will behave badly?
  28. Is it allowed to cast away const on a const-defined object as long as it is not actually modified?
  29. Should every class have a virtual destructor?
  30. Setting extra bits in a bool makes it true and false at the same time

Leave a Comment