Observable behavior and undefined behavior — What happens if I don’t call a destructor?

by

I simply do not understand what “depends on the side effects” means.

It means that it depends on something the destructor is doing. In your example, modifying *p or not modifying it. You have that dependency in your code, as the output would differ if the dctor wouldn’t get called.

In your current code, the number that is printed, might not be the same number that would have returned by the second rand() call. Your program invokes undefined behavior, but it’s just that UB here has no ill effect.

If you wouldn’t print the value (or otherwise read it), then there wouldn’t be any dependency on the side effects of the dcor, and thus no UB.

So:

Is forgetting to call a destructor any different than forgetting to call an ordinary function with the same body?

Nope, it’s not any different in this regard. If you depend on it being called, you must make sure it’s called, otherwise your dependency is not satisfied.

Furthermore, at what point is it correct to say the program “depends” on the destructor? Does it do so if the value was random — or in general, if there is no way for me to distinguish the destructor from running vs. not running?

Random or not doesn’t matter, because the code depends on the variable being written to. Just because it’s difficult to predict what the new value is doesn’t mean there’s no dependency.

What if I never read the value?

Then there’s no UB, as the code has no dependency on the variable after it was written to.

Under which condition(s), if any, does this program exhibit Undefined Behavior?

There are no conditions. It’s always UB.

Exactly which expression(s) or statement(s) cause this, and why?

The expression:

printf("%d", x);

because it introduces the dependency on the affected variable.

More Related Contents:

  1. Accessing inactive union member and undefined behavior?
  2. When does invoking a member function on a null instance result in undefined behavior?
  3. Has C++ standard changed with respect to the use of indeterminate values and undefined behavior in C++14?
  4. Optimizing away a “while(1);” in C++0x
  5. Does initialization entail lvalue-to-rvalue conversion? Is `int x = x;` UB?
  6. Do I need to cast to unsigned char before calling toupper(), tolower(), et al.?
  7. Is `reinterpret_cast`ing between hardware SIMD vector pointer and the corresponding type an undefined behavior?
  8. Why does left shift operation invoke Undefined Behaviour when the left side operand has negative value?
  9. Does “Undefined Behavior” really permit *anything* to happen? [duplicate]
  10. Where exactly does C++ standard say dereferencing an uninitialized pointer is undefined behavior?
  11. Difference between Undefined Behavior and Ill-formed, no diagnostic message required
  12. Is passing a C++ object into its own constructor legal?
  13. Are multiple mutations of the same variable within initializer lists undefined behavior pre C++11
  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. In C++11, does `i += ++i + 1` exhibit undefined behavior?
  16. So why is i = ++i + 1 well-defined in C++11?
  17. Why is f(i = -1, i = -1) undefined behavior?
  18. Implementing a std::vector like container without undefined behavior
  19. Pseudo-destructor call does not destroy an object
  20. Are pointer variables just integers with some operators or are they “symbolic”?
  21. The behaviour of floating point division by zero
  22. Can branches with undefined behavior be assumed unreachable and optimized as dead code?
  23. Dangling references and undefined behavior
  24. Lifetime of object is over before destructor is called?
  25. In which versions of the C++ standard does “(i+=10)+=10” have undefined behaviour?
  26. Pure virtual destructor in C++
  27. Division by zero: Undefined Behavior or Implementation Defined in C and/or C++?
  28. In which access control context are concepts evaluated?
  29. Is it Undefined Behaviour to cast away the constness of a function parameter?
  30. Does the standard mandate an lvalue-to-rvalue conversion of the pointer variable when applying indirection?

Leave a Comment