Question

In Effective C++, Item 3, Scott Meyers suggests overloading operator* for a class named Rational:

    class Rational { ... };
    const Rational operator*(const Rational& lhs, const Rational& rhs);

The reason for the return value being const-qualified is explained in the following line: if it were not const, programmers could write code such as:

    (a * b) = c;

or, more probably:

     if (a*b = c)

Fair enough.
Now I’m confused as I thought that the return value of a function, here operator*, was a rvalue, therefore not assignable. I take it not being assignable because if I had:

    int foo();
    foo() += 3;

that would fail to compile with invalid lvalue in assignment.
Why doesn’t that happen here? Can someone shed some light on this?

EDIT: I have seen many other threads on that very Item of Scott Meyers, but none tackled the rvalue problem I exposed here.

Answer 1

The point is that for class types, a = b is just a shorthand to a.operator=(b), where operator= is a member function. And member functions can be called on rvalues.

Note that in C++11 you can inhibit that by making operator= lvalue-only:

class Rational
{
public:
  Rational& operator=(Rational const& other) &;
  // ...
};

The & tells the compiler that this function may not be called on rvalues.