Because it never happens in a correct program, and making a check for something that never happens is wasteful (and to make that check it needs to store the owning thread ID, which is also wasteful). Note that it being undefined allows debug implementations to throw an exception, for example, while still allowing release implementations … Read more
Although this is technically undefined behavior, in practice no native architecture checks for out-of-bounds memory access at a finer granularity than the size of a word. So while garbage past the terminator may end up being read, the result will not be a crash.
In C++ as in C, shifts are limited to the size (in bits) of the value shifted. For instance, if unsigned int is 32 bits, then a shift of more than 31 is undefined. In practice, a common result is that the 5 least-significant bits of the shift amount are used and the higher order … Read more
Your second case is undefined behavior, you are no longer using aggregate initialization, it is still list initialization but in this case you have a user defined constructor which is being called. In order to pass the second argument to your constructor it needs to evaluate foo.i but it is not initialized yet since you … Read more
Since the operations are unsequenced, there is nothing to say that the instructions performing the assignment cannot be interleaved. It might be optimal to do so, depending on CPU architecture. The referenced page states this: If A is not sequenced before B and B is not sequenced before A, then two possibilities exist: evaluations of … Read more
This is topic that is under active discussion, we can see this in the proposal p0593: Implicit creation of objects for low-level object manipulation. This is a pretty solid discussion of the issues and why they are not fixable without changes. If you have different approaches or strong views on the approaches being considered you … Read more
I think the second opus of What every C programmer should know about Undefined Behavior might help illustrate this issue. Taking the example of the blog: void contains_null_check(int *P) { int dead = *P; if (P == 0) return; *P = 4; } Might be optimized to (RNCE: Redundant Null Check Elimintation): void contains_null_check_after_RNCE(int *P) … Read more
A really common pitfall in C++ programs, and even in Java programs, is modifying a collection while iterating over it, like this: for (it: collection) { if (predicate(*it)) { collection.remove(it); } } For C++ standard library collections, this causes undefined behaviour. Maybe the iteration will work until you get to the last entry, but the … Read more
There are a number of places where the language of the Standard gives compilers freedoms beyond what are required for useful optimizations, but which would instead provide compilers with ways to throw the Principle of Least Astonishment out the window. The way the rules about endless loops are written fits that category. Most of the … Read more
… or a value computation using the value of the same scalar object … The important part is bolded here. The left hand side does not use the value of i for the value computation. What is being computed is a glvalue. Only afterwards (sequenced after), the value of the object is touched and replaced. … Read more