Why a different type variable can be used as an argument of a parameter of const reference parameter in C++

Question

void foo(const int& v) {
    int x = v;
    std::cout << x;
}

int main()
{
    unsigned y = 1;
    foo(y);
}

Is passing y in place of a const int& legal in C++

Answer 1

There are two factors that allow your code to work. First, function arguments are allowed up to one implicit conversion if it would allow them to match an overload. Second, const references can bind to temporaries. What is happening here is y is implicitly converted to int, creating a temporary copy. v is then bound to that temporary.

Consider the following example :

#include <iostream>

void foo(const unsigned int & v) {
    std::cout << &v << '\n';
}

void bar(const int & v) {
    std::cout << &v << '\n';
}

int main()
{
    unsigned int y = 1;
    std::cout << &y << '\n';
    foo(y);
    bar(y);
    return 0;
}

You will find that foo(y) prints the same address as y where as bar(y) prints a different address. This won't work with non-const references. Notably, if you could, it would mean that changing v might not actually change y.

Answer 2

Yes, this this can be quite annoying. Compilation passes due to an implicit conversion of y to an anonymous temporary int at the calling site, and a const int& binding is allowed.

You can defeat this by writing

void foo(unsigned v) = delete;

or even

template<typename Y> void foo(Y v) = delete;

so all overloads other than the one you have explicitly given are deleted.