Here be dragons
Looking through the materials of the GoingNative 2012 conference (which I strongly advise all C ++ programmers to look at), I drew attention to one example code:

Can you, without peeking back, say what this program will print and most importantly why ?
Under the cut, Google’s Clang developer ’s suggestion is why this code works the way it works. Once again, who didn’t catch it: the developer of the C ++ compiler from Google does not know this for sure, he just has an assumption.
When compiled in accordance with the C ++ 98 standard, this code will print “ X! ”, When compiled in accordance with the C ++ 98 standard, this code will print “ Pointer! ”.

Let's look carefully at the line
As you can see, an instance of the S structure is created here. It does not have an explicit constructor, which means that the default constructor is called. And here enters the scene Standard C ++ 11 with its advanced support of constant expressions ( Generalized constant expressions ). Any function (including a constructor) in C ++ 11 can be declared as always returning the same expression. This is done to be able to write this code:
Constant expressions are used in array declarations, in enums, in switch \ case blocks. And the C ++ 11 compiler tries any function that can be constant, considered constant, in order to be able to use it in all these places. But what about the constructor of structure S ? Well, if he always assigns a certain number to the variable n (and the standard does not prohibit this), then it can also be a constant expression. And why would he assign n different values each time? Assigns zero. Why exactly zero? Do you have any smarter meaning on your mind?
So, the above line is equivalent:
Well, this, as we know, is completely equivalent:
And this translates to void * rather than to struct X (even with the corresponding constructor X (int) ). And here we have the explicit call void f (void *) ! Well, it prints " Pointer! ".
Why doesn't this happen in a compiler with C ++ 98 support? Yes, because he does not have this very advanced support for constant expressions. The default constructor of structure S has no reason to set property n to zero (the standard does not require this). Well, he doesn’t. So the string f (S (). N); cannot be unambiguously converted to f (0); with all the ensuing consequences.
The C ++ 11 standard is new; its support in compilers is also raw. Be prepared for such surprises.

#include
struct S { int n; };
struct X { X(int) {} };
void f(void*) {
std::cerr << "Pointer!\n";
}
void f(X) {
std::cerr << "X! \n";
}
int main() {
f(S().n);
}
Can you, without peeking back, say what this program will print and most importantly why ?
Under the cut, Google’s Clang developer ’s suggestion is why this code works the way it works. Once again, who didn’t catch it: the developer of the C ++ compiler from Google does not know this for sure, he just has an assumption.
Answer
When compiled in accordance with the C ++ 98 standard, this code will print “ X! ”, When compiled in accordance with the C ++ 98 standard, this code will print “ Pointer! ”.
# clang++ -std=c++98 -g -o cxx11-4 cxx11-4.cpp
# ./cxx11-4
X!
# clang++ -std=c++11 -g -o cxx11-4 cxx11-4.cpp
# ./cxx11-4
Pointer!
Question to the developers of the C ++ 11 standard

Explanations
Let's look carefully at the line
f(S().n);
As you can see, an instance of the S structure is created here. It does not have an explicit constructor, which means that the default constructor is called. And here enters the scene Standard C ++ 11 with its advanced support of constant expressions ( Generalized constant expressions ). Any function (including a constructor) in C ++ 11 can be declared as always returning the same expression. This is done to be able to write this code:
int get_five() {return 5;}
int some_value[get_five() + 7];
Constant expressions are used in array declarations, in enums, in switch \ case blocks. And the C ++ 11 compiler tries any function that can be constant, considered constant, in order to be able to use it in all these places. But what about the constructor of structure S ? Well, if he always assigns a certain number to the variable n (and the standard does not prohibit this), then it can also be a constant expression. And why would he assign n different values each time? Assigns zero. Why exactly zero? Do you have any smarter meaning on your mind?
So, the above line is equivalent:
f(0);
Well, this, as we know, is completely equivalent:
f(NULL);
And this translates to void * rather than to struct X (even with the corresponding constructor X (int) ). And here we have the explicit call void f (void *) ! Well, it prints " Pointer! ".
Why doesn't this happen in a compiler with C ++ 98 support? Yes, because he does not have this very advanced support for constant expressions. The default constructor of structure S has no reason to set property n to zero (the standard does not require this). Well, he doesn’t. So the string f (S (). N); cannot be unambiguously converted to f (0); with all the ensuing consequences.
Conclusion
The C ++ 11 standard is new; its support in compilers is also raw. Be prepared for such surprises.