Question

If you have this function

template<typename T> f(T&);

And then try to call it with, let’s say an rvalue like

f(1);

Why isn’t T just be deduced to be const int, making the argument a const int& and thus bindable to an rvalue?

Answer 1

This is mentioned as a potential solution in the document I linked in the recent C++0x forwarding question.

It would work fairly well, but it breaks existing code. Consider (straight from the document):

template<class A1> void f(A1 & a1)
{
    std::cout << 1 << std::endl;
}

void f(long const &)
{
    std::cout << 2 << std::endl;
}

int main()
{
    f(5);              // prints 2 under the current rules, 1 after the change
    int const n(5);
    f(n);              // 1 in both cases
}

Or

// helper function in a header

template<class T> void something(T & t) // #1
{
    t.something();
}

// source

#include <vector>

void something(bool) // #2
{
}

int main()
{
    std::vector<bool> v(5);

    // resolves to #2 under the current rules, #1 after the change
    something(v[0]);
}

This also fails to forward the value category (lvalue or rvalue), which isn’t much of a problem in C++03. But since this fix could only be done during C++0x, we’d effectively shutting ourselves out from rvalue references when forwarding (a bad thing). We should strive for a better solution.