The following program:
#include <iostream>
struct A
{
A() { std::cout << "A()\n"; }
A(int) { std::cout << "A(int)\n"; }
};
struct C {
operator int() {
std::cout << "operator int\n";
return 42;
}
operator A() {
std::cout << "operator A\n";
return A();
}
};
int main() {
auto a = A{C{}};
};
compiles and, when run, prints:
operator A
A()
See Godbolt link.
This shows that the move constructor of A was selected to perform the initialization, with C::operator A() being invoked to convert C into the type that the move constructor expects.
Alternatively, the A::A(int) constructor could have been selected, with C::operator int() being invoked. But A::A(int) loses overload resolution, apparently.
Why does this happen? I am not able to see any rule in the standard that explains why the move constructor of A wins the overload resolution.
(This question is inspired by this answer; I could not understand why the code in that answer works.)
