Does “Undefined Behavior” really permit *anything* to happen? [duplicate]

by

Yes, it permits anything to happen. The note is just giving examples. The definition is pretty clear:

Undefined behavior: behavior for which this International Standard imposes no requirements.

Frequent point of confusion:

You should understand that “no requirement” also means means the implementation is NOT required to leave the behavior undefined or do something bizarre/nondeterministic!

The implementation is perfectly allowed by the C++ standard to document some sane behavior and behave accordingly.1 So, if your compiler claims to wrap around on signed overflow, logic (sanity?) would dictate that you’re welcome to rely on that behavior on that compiler. Just don’t expect another compiler to behave the same way if it doesn’t claim to.

1Heck, it’s even allowed to document one thing and do another. That’d be stupid, and it’d probably make you toss it into the trash—why would you trust a compiler whose documentation lies to you?—but it’s not against the C++ standard.

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. Where exactly does C++ standard say dereferencing an uninitialized pointer is undefined behavior?
  10. Difference between Undefined Behavior and Ill-formed, no diagnostic message required
  11. Is passing a C++ object into its own constructor legal?
  12. Are multiple mutations of the same variable within initializer lists undefined behavior pre C++11
  13. Does not evaluating the expression to which sizeof is applied make it legal to dereference a null or invalid pointer inside sizeof in C++?
  14. In C++11, does `i += ++i + 1` exhibit undefined behavior?
  15. So why is i = ++i + 1 well-defined in C++11?
  16. Why is f(i = -1, i = -1) undefined behavior?
  17. Implementing a std::vector like container without undefined behavior
  18. Are pointer variables just integers with some operators or are they “symbolic”?
  19. The behaviour of floating point division by zero
  20. Can branches with undefined behavior be assumed unreachable and optimized as dead code?
  21. Dangling references and undefined behavior
  22. In which versions of the C++ standard does “(i+=10)+=10” have undefined behaviour?
  23. Observable behavior and undefined behavior — What happens if I don’t call a destructor?
  24. Do I really need to implement user-provided constructor for const objects?
  25. Do all pointers have the same size in C++?
  26. Force all classes to implement / override a ‘pure virtual’ method in multi-level inheritance hierarchy
  27. Why does the standard differentiate between direct-list-initialization and copy-list-initialization?
  28. C++ – Why static member function can’t be created with ‘const’ qualifier
  29. Is a constexpr array necessarily odr-used when subscripted?
  30. Does C have One Definition Rule like C++?

Leave a Comment