TL;DR: The operations are well defined according to the draft C++ standard. Details We can see that by going to the draft C++ standard section 5.9 Relational operators which says (emphasis mine going forward): The operands shall have arithmetic, enumeration, or pointer type, or type std::nullptr_t. The operators < (less than), > (greater than), <= … Read more
To me, the relevant justification is: This is intended to allow compiler transfor- mations, such as removal of empty loops, even when termination cannot be proven. Presumably, this is because proving termination mechanically is difficult, and the inability to prove termination hampers compilers which could otherwise make useful transformations, such as moving nondependent operations from … Read more
Up to and including C++17 pi is not a constant introduced into the language, and it’s a pain in the neck. I’m fortunate in that I use boost and they define pi with a sufficiently large number of decimal places for even a 128 bit long double. If you don’t use Boost then hardcode it … Read more
In C++11 the act of “assignment”, i.e. the side-effect of modifying the LHS, is sequenced after the value computation of the right operand. Note that this is a relatively “weak” guarantee: it produces sequencing only with relation to value computation of the RHS. It says nothing about the side-effects that might be present in the … Read more
Perhaps not the most useful, but not completely worthless. You may use it to declare a local variable available within switch scope. switch (foo) { int i; case 0: i = 0; //…. case 1: i = 1; //…. } The standard (N1579 6.8.4.2/7) has the following sample: EXAMPLE In the artificial program fragment switch (expr) … 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
public class J { public static void main(String[] args) { String main = “The character sequence \”main\” is an identifier, not a keyword or reserved word.”; System.out.println(main); } } This compiles, and when executed, emits this output: The character sequence “main” is an identifier, not a keyword or reserved word. The character sequence main is … Read more
Your pseudo-code is pretty much correct. For this example, suppose we had a method call foo.bar() where foo: T. I’m going to use the fully qualified syntax (FQS) to be unambiguous about what type the method is being called with, e.g. A::bar(foo) or A::bar(&***foo). I’m just going to write a pile of random capital letters, … Read more
The answer is a definite yes. On the plus side there is: Code that previously implicitly copied objects will now implicitly move them when possible. On the negative side, several examples are listed in the appendix C of the standard. Even though there are many more negative ones than positive, each one of them is … Read more
Yes, the code is standard conforming. The + triggers a conversion to a plain old function pointer for the lambda. What happens is this: The compiler sees the first lambda ([]{}) and generates a closure object according to §5.1.2. As the lambda is a non-capturing lambda, the following applies: 5.1.2 Lambda expressions [expr.prim.lambda] 6 The … Read more