Can you (and should you) disambiguate a function call taking T and const reference to T?

Question

If we have:

void foo(int) {}
void foo(const int&) {}

we cannot call foo like this:

foo(3);

because the call is ambiguous:

error: call of overloaded 'foo(int)' is ambiguous
40 |     foo(3);
   |          ^
note: candidate: 'void foo(int)'
36 | void foo(int) {}
   |      ^~~
note: candidate: 'void foo(const int&)'
37 | void foo(const int&) {}
   |      ^~~

What we can do is explicitly provide the correct overload, for example via a function pointer:

auto (*ptr)(const int&) -> void = foo;
ptr(3); // calls the "const int&" overload, obviously

However, that kind of defeats the purpose of convenient overloads. The question is - can I somehow disambiguate the call in a more... elegant? way? Are there ever cases where it would be desired to provide both overloads, for T and for const T&?

Answer 1

You can exploit templates. Overload resolution favours a non-template function over a template one, so converting one of the overloads to a template is a sufficent disambiguation:

#include <iostream>

void foo(int n)
{
    std::cout << "By Value  " << n;
}

template<int N = 0>
void foo(const int& n)
{
    std::cout << "By Reference " << n;
}

int main() {
    foo(1);
    foo<>(1);
}

Granted, you need <> to call the template one, but this could have some uses. Ostensibly more elegant than a function pointer? But alas it's not really much better than renaming say foo<> to bar.

Answer 2

It seems like you're asking whether we can force the overload resolution mechanism to select one signature over the other, rather than explicitly spelling out the signature that you want.

As far as I know, the only way to force overload resolution to pick the int overload over the const int& overload is to cast the argument to a volatile int glvalue, and there is no way to force overload resolution to pick the const int& overload over the int overload.

In any case, I can't think of any reason why one would want to write this particular set of overloads.