Should template parameter T be resolving to T& when a function takes argument of T&& and is passed an lvalue?

Question

I'm trying to get my head around perfect forwarding in C++, and so I've written the following quick and dirty bit of code to test this.

class CValue
{
public:

    CValue(int i) :
        m_i(i)
    {
        printf("Default constructor called!\r\n");
    }

    CValue(const CValue& src) :
        m_i(src.m_i)
    {
        printf("Copy constructor called!\r\n");
    }

    CValue(CValue&& src) :
        m_i(src.m_i)
    {
        printf("Move constructor called!\r\n");
    }

    CValue& operator=(const CValue& src)
    {
        m_i = src.m_i;
        printf("Copy assignment called!\r\n");
        return *this;
    }

    CValue& operator=(CValue&& src)
    {
        m_i = src.m_i;
        printf("Move assignment called!\r\n");
        return *this;
    }

    int     m_i;
};

template <typename T>
void PerfectForwarding(T&& tValue)
{
    T tValue1 = tValue;
    tValue1.m_i = 10;
}

int _tmain(int argc, _TCHAR* argv[])
{
    CValue v(0);
    PerfectForwarding(v);

    printf("%d\r\n", v.m_i);

    return 0;
}

When I build and run this code as a console application I get the answer 10, when I was expecting 0.

It seems that the line:

T tValue1 = tValue;

in the PerfectForwarding function is being resolved to:

CValue& tValue1 = tValue;

instead of:

CValue tValue1 = tValue;

So the compiler is resolving T to be CValue&, which I didn't expect.

I tried invoking the function from _tmain by explicitly declaring the template parameter type, i.e.

PerfectForwarding<CValue>(v);

but this fails to compile with the following error:

error C2664: 'void PerfectForwarding<CValue>(T &&)' : cannot convert
              argument 1 from 'CValue' to 'CValue &&'
              with
              [
                  T=CValue
              ]
You cannot bind an lvalue to an rvalue reference

I can force the desired behaviour through changing the line in the PerfectForwarding function to the following:

typename std::remove_reference<T>::type tValue1 = tValue;

but I didn't think this should be necessary. By the reference collapsing rules the type of the argument (T&&) should become CValue& (as T&& & -> T&), but T itself should be simply CValue, surely? Is this a bug in the VC12 compiler's handling of rvalue references, or am I misunderstanding something about rvalue references and templates?

I'm using Visual Studio 2013 (VC12 compiler) in debug with all optimisation turned off.

Answer 1

When the compiler sees just T&& it's going to try to deduce T to something that allows the function to be called with whatever you're giving it. So you wind up with T being Cvalue& when called with an lvalue so the reference collapsing (as you've pointed out) can kick in.

This matters when you try to forward the argument. std::forward<T>(v) will either forward the argument as an lvalue or an rvalue depending on what T is. If it has been deduced to an lvalue reference, it will forward it as an lvalue, if it hasn't, it will be forwarded as an rvalue. The type T is the only thing that distinguishes.

By the reference collapsing rules the type of the argument (T&&) should become CValue& (as T&& & -> T&), but T itself should be simply CValue, surely?
If called with an lvalue it goes (T&& v) "okay, I can't bind an rvalue reference to an lvalue, but if I make T itself be an lvalue reference then this works." T is deduced to be Cvalue& so that (T&& v) expands to (Cvalue& && v). Now the reference is collapsed (Cvalue& v). The type T must be an lvalue-reference type for this to work.

If you provide the template parameter explicitly then you're not really addressing the issue. The first way around this is the remove_reference as you've found. You could also use auto which makes more sense since this is generic programming

auto tValue1 = tValue;

In any case, the auto won't deduce to a reference. For what you've provided, you'd be better off using a const lvalue reference which can bind to both lvalues and rvalues.

template <typename T>
void PerfectForwarding(const T& tValue)
{
    T tValue1 = tValue;
    tValue1.m_i = 10;
}

this doesn't allow for forwarding, but it's not a forwarding function as-is anyway.

If you wanted to handle lvalues differently you could provide two overloads

template <typename T>
void PerfectForwarding(T& tValue);

template <typename T>
void PerfectForwarding(T&& tValue);

When called with an lvalue, the former will be preferred.

Answer 2

The behaviour is correct. Perfect forwarding is implemented by deducing an lvalue reference for the type when the argument is an lvalue.

You're saying

By the reference collapsing rules the type of the argument (T&&) should become CValue& (as T&& & -> T&), but T itself should be simply CValue, surely?

But where would the & in T&& & come from if T was just CValue? The entire reason why T&& works as a forwarding reference is that the T becomes an lvalue reference, CValue& in your case, and then reference collapsing gets T && -> CValue & && -> CValue &.

The relevant section of the standard is C++11 14.8.2.1/3 (P is the function template parameter type and A s the type of the argument in the call, defined in 14.8.2.1/1):

If P is a cv-qualified type, the top level cv-qualifiers of P’s type are ignored for type deduction. If P is a reference type, the type referred to by P is used for type deduction. If P is an rvalue reference to a cv-unqualified template parameter and the argument is an lvalue, the type “lvalue reference to A” is used in place of A for type deduction.

(Emphasis mine)

Answer 3

The compiler does the right thing. In a line like

template<typename T>
void f(T&& param){}

T is being deduced as reference if you pass a lvalue, and a simple type if you pass a rvalue. So int x; f(x); deduces T as int&, and f(1) deduces T as int.

That's how perfect forwarding works. Basically, you have the following rules for reference collapsing:

& &   -> &
& &&  -> &
&& &  -> &
&& && -> &&

See also

Syntax for universal references

for more details.