Difference between Undefined Behavior and Ill-formed, no diagnostic message required

by

The standard is not always as coherent as we would like, since
it is a very large document, written (in practice) by a number
of different people, and despite all of the proof-reading that
does occur, inconsistencies slip through. In the case of
undefined behavior (and errors in general), I think there is an
additional problem in that for much of the most basic things
(pointers, etc.), the C++ standard inspires from C. But the
C standard takes the point of view that all errors are undefined
behavior, unless stated otherwise, where as the C++ standard
tries to take the point of view that all errors require
a diagnostic, unless stated otherwise. (Although they still
have to allow for the case where the standard omits to specify
a behavior.) I think this accounts for a lot of the
inconsistency in the wording.

Globally, the inconsistency is regrettable, but on the whole, if
the standard says that something is erroneous, or ill-formed,
then it requires a diagnostic, unless the standard says that it
doesn’t, or that it is undefined behavior. In something like
“ill-formed; no diagnostic required“, the “no diagnostic
required” is important, because otherwise, it would require
a diagnostic. As for the difference between “ill-formed; no
diagnostic required” and “undefined behavior”, there isn’t any.
The first is probably more frequent in cases where the code is
incorrect, the second where it is a run-time issue, but it’s not
systematic. (The specification of the one definition
rule—clearly a compile time issue—ends with “then
the behavior is undefined”.)

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. 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. reinterpret_cast creating a trivially default-constructible object
  25. Why is out-of-bounds pointer arithmetic undefined behaviour?
  26. Is `long` guaranteed to be at least 32 bits?
  27. Can std::launder be used to convert an object pointer to its enclosing array pointer?
  28. Is it a strict aliasing violation to alias a struct as its first member?
  29. Can undefined behavior erase the hard drive?
  30. Overload resolution with ref-qualifiers

Leave a Comment