Unable to use operator<< for anonymous object

Question

In my code below, I am creating a class that takes in variables using operator<< and processes the variables accordingly. The exact logic that will go inside the class is omitted for simplicity & clarity.

The issue that I'm facing is that when I try to create an anonymous instance of the object, and use that directly with the (<<) operator, most compilers would complain - something along the lines of (no match for 'operator<<')

From what I understand, calling the class directly ( TestObject() ) is a legal expression, and it should instantiate an anonymous object that gets passed into the operator.

Appreciate your thoughts on why this does not compile?

typedef unsigned int uint32;

class TestObject
{
public:
   TestObject()
      : mValue(0)
   {
   }

   uint32 GetValue() const
   {
      return mValue;
   }

private:
   uint32 mValue;
};

template <typename T>
TestObject& operator<<(TestObject& o, const T& t)
{
   return o;
}

void TestObjectTest()
{
   TestObject myTestObject;
   uint32 newValue = 123;
   const uint32 resultValue = (myTestObject << newValue).GetValue(); // This compiles for both visual studio 2013 and gcc.
   const uint32 resultValue2 = (TestObject() << newValue).GetValue(); // Compiles using visual studio 2013, but does not compile using x86-64 gcc 6.2: "no match for 'operator<<' in 'TestObject() << newValue'
}

int main(void)
{
    TestObjectTest();
    return 0;
}

You shouldnt be able to bind a temporary to a non const reference I'm surprised that compiles in VS — Borgleader, Jul 14 '17 at 18:15

NathanOliver · Answer 1 · 2017-07-14T19:51:31.790

3

TestObject() yields a temporary TestObject. Since it is not a temporary you cannot bind it to a lvalue reference (except for MSVS's evil extension). If your operator does not need to modify the TestObject then simply changing it to take a const& is enough:

template <typename T>
const TestObject& operator<<(const TestObject& o, const T& t)
{
   return o;
}

If you need to modify the value then you need to add another overload and take in a rvalue reference. That will bind to the temporary and allow you to modify it:

template <typename T>
TestObject& operator<<(TestObject&& o, const T& t)
{
   return o;
}

edited Jul 14 '17 at 19:51

answered Jul 14 '17 at 18:16

NathanOliver

171,901
28
288
402

1

Beware that the first solution need explicit cast to remove constness on return. – Jean-Baptiste Yunès Jul 14 '17 at 18:20
@Jean-BaptisteYunès Good call. I just changed it to return a `const &`. – NathanOliver Jul 14 '17 at 18:21
Is it valid to return a reference to an rvalue reference parameter? Won't this be a "dangling" reference when the temporary argument gets destroyed? – zett42 Jul 14 '17 at 19:33
@zett42 Not it is not. I forgot about that. It should work now. – NathanOliver Jul 14 '17 at 19:52
@zett42 Actually I think you have to return it by reference if you want to chain it. The standard streams do the same thing. I think it is safe as long as at the end you don't yourself capture the returned reference. – NathanOliver Jul 14 '17 at 19:56

Unable to use operator<< for anonymous object

1 Answers1