most-vexing-parse

struct X { X() { std::cout << "X()\n"; } X(int) { std::cout << "X(int)\n"; } }; const int answer = 42; int main() { X(answer); } I would have expected this to print either X(int) , because X(answer); could be interpreted as a cast from int to X , or nothing at all, because X(answer); could be interpreted as the declaration of a variable. However, it prints X() , and I have no idea why X(answer); would call the default constructor. BONUS POINTS: What would I have to change to get a temporary instead of a variable declaration? nothing at all, because X(answer); could be interpreted as the

This question already has an answer here: A confusing detail about the Most Vexing Parse 4 answers I saw a code here at Cpp Quiz [Question #38] #include <iostream> struct Foo { Foo(int d) : x(d) {} int x; }; int main() { double x = 3.14; Foo f( int(x) ); std::cout << f.x << std::endl; return 0; } It is said there that this code is ill formed because Foo f( int(x) ); will be treated as a function declaration rather than an object declaration of type Foo . As far as I know, this is an instance of most vexing parse. My question is what is this syntax int(x) in statement Foo f( int(x) ); means? So

For example a declaration such as that: int (x) = 0; Or even that: int (((x))) = 0; I stumbled upon this because in my code I happened to have a fragment similar to the following one: struct B { }; struct C { C (B *) {} void f () {}; }; int main() { B *y; C (y); } Obviously I wanted to construct object C which then would do something useful in its destructor. However as it happens compiler treats C (y); as a declaration of variable y with type C and thus it prints an error about y redefinition. Interesting thing is that if I write it as C (y).f () or as something like C (static_cast<B*> (y))

My question is how the following line can be parsed as a function declaration: vector<int> v(istream_iterator<int>(cin), istream_iterator<int>()); I understand most of the details of the Most Vexing Parse and why the second temporary iterator can be interpreted as a type that is a function returning an iterator and taking no arguments, but what I don't get is why the first temporary iterator can be interpreted as a type. What type does it represent? My thought is that it would be some sort of function type, but I can't see how the name cin gets used. Is it declaring that the parameter is an