Question

Some time ago I was confused by the following behavior of some code when I wanted to write a is_callable<F, Args...> trait. Overload resolution won’t call functions accepting arguments by non-const ref, right? Why doesn’t it reject in the following because the constructor wants a Test&? I expected it to take f(int)!

struct Test {
  Test() { }

  // I want Test not be copyable from rvalues!
  Test(Test&) { }

  // But it's convertible to int
  operator int() { return 0; }
};

void f(int) { }
void f(Test) { }

struct WorksFine { };
struct Slurper { Slurper(WorksFine&) { } };
struct Eater { Eater(WorksFine) { } };

void g(Slurper) { }
void g(Eater) { } // chooses this, as expected

int main() {
  // Error, why?
  f(Test());

  // But this works, why?
  g(WorksFine());
}

Error message is

m.cpp: In function 'int main()':
m.cpp:33:11: error: no matching function for call to 'Test::Test(Test)'
m.cpp:5:3: note: candidates are: Test::Test(Test&)
m.cpp:2:3: note:                 Test::Test()
m.cpp:33:11: error:   initializing argument 1 of 'void f(Test)'

Can you please explain why one works but the other doesn’t?

Answer 1

Overload resolution picks the function that is the closest match to the supplied argument. You supplied a Test. No conversion necessary — identity conversion used. Thus function resolution chooses f(Test). Test can’t be copied from rvalue, which you supplied, but overload resolution has succeeded already…conversion to int is never checked.

g(Eater) is chosen because the types don’t exactly match, the identity conversion is NOT used, and the compiler has to find a conversion routine that works. g(Slurper) doesn’t because you can’t make one out of the supplied argument.

“Why doesn’t this one fail: struct A { operator int(); }; void f(A&); void f(int); void g() { f(A()); }“

Because f(A&) is not a viable overload for the supplied argument. In this case the parameter is a reference and the fact that temps don’t bind to non-const is allowed to effect the resolution. In this case it does and the that version of the function becomes a non-candidate, leaving only the one and it works.