在C ++中的单个语句中通过非常量引用使用临时对象

Question

Here is the code:

namespace NS
{
    class B
    {
    public:
        template<typename T> friend B& operator<<(B& b, T const& obj);
    };

    template<typename T> B& operator<<(B& b, T const& obj)
    {
        // using b and obj
        return b;
    }
}

int main()
{
    NS::B() << 2.71 << 123 << "abcdef"; // doesn't compile in gcc
    NS::B b; b << 2.71 << 123 << "abcdef"; // OK
}

The first line in main compiles in VS2015 (and some earlier ones) and doesn't compile in gcc (I tried in 6.3, 4.3.2).

Which compiler does the right thing? I thought the temporary object's (NS::B()) lifetime would be up to the end of the statement (;), so it's ok to pass it to my operator<< by non-const reference. If it isn't so, could you tell me why?

Thanks.

Answer 1

The standard says that temporary objects may not be converted to non-const lvalue references implicitly. See [dcl.init.ref]/8.6.3.5.2 in n4628.

Otherwise, the reference shall be an lvalue reference to a non-volatile const type (ie, cv1 shall be const), or the reference shall be an rvalue reference. [ Example:

 double& rd2 = 2.0; // error: not an lvalue and reference not const int i = 2; double& rd3 = i; // error: type mismatch and reference not const 

— end example ]

To solve this:

template<class T>
T& as_lvalue(T&&t){return t;}

This function takes an rvalue t and returns an lvalue reference.

as_lvalue(NS::B()) << 2.71 << 123 << "abcdef";

The above is both standard compliant and safe.