deducing references to const from rvalue arguments

Question

Okay, this may seem like a silly question, but here it goes:

template 
void foo(T& x)
{
}

int main()
{
    foo(42);
    // error in pa         


        

Answer 1

Them's the rules ;-). If you leave the compiler to deduce the type from the argument, it picks the simplest thing it can.

It doesn't seem unreasonable to me. Your template is saying it expects a non-const reference, so it doesn't compile with an rvalue.

You could either tell it what you mean at the call site: foo<int const>(42); or change your template to make it clear it doesn't need a mutable reference: template <typename T> void foo(T const & x) { }.

In C++11 you have more options for expressing what your template will and will not accept.

Answer 2

Be it template or normal functions, rvalue cannot be passed by reference. (so const T& works but not T&).

What is preventing C++ to instantiate the foo function template with T = const int instead?

Suppose, C++ allows and makes T = const int instead. Now after sometime you change foo as,

template<typename T>
void foo (T& x)
{
  x = 0;
}

Now compiler has to generate error. For end user the experience will be strange, as for a valid statement like x = 0; it started giving error. That could be the reason that why compiler prevents at the first stage itself!

Answer 3

The problem is that template type deduction has to work out an exact match, and in that particular case, because of the reference in the signature, an exact match requires an lvalue. The value 42, is not an lvalue, but rather an rvalue, and resolving T with const int would not yield a perfect match. Since template type deduction is limited to exact matches, that deduction is not allowed.

If instead of using a literal you use a non mutable lvalue, then the compiler will deduce the type appropriatedly, as const int will become a perfect match for the argument:

const int k = 10;
foo( k );            // foo<const int>( const int & ) is a perfect match

Now there is a special rule that enables calling a function that takes a const reference (nonmutable lvalue) with an rvalue, that implies creation of a temporary lvalue which is later bound to the reference, but for that rule to kick in the function has to have that signature before hand, which is why explicitly stating that the type of the template is const int works: foo<const int>(42).