Function Overloading Based on Value vs. Const Reference

Question

Does declaring something like the following

void foo(int x)        { std::cout << \"foo(int)\"         << std::endl; }
void foo(const int &x)         


        

Answer 1

The compiler can't. Both definitions of foo can be used for all 'variants' of int.

In the first foo, a copy of the int is made. Copying an int is always possible.

In the second foo, a reference to a const int is passed. Since any int can be cast to a const int, a reference to it can be passed as well.

Since both variants are valid in all cases, the compiler can't choose.

Things become different if you e.g. use the following definition:

void foo (int &x);

Now calling it with foo(9) will take the first alternative, since you can't pass 9 as a non-const int reference.

Another example, if you replace int by a class where the copy constructor is private, then the caller can't make a copy of the value, and the first foo-variant will not be used.