Thread: Question about return value of * operator

Hi.
I'm reading Effective C++ 3rd Edition, and I'm a bit confused about one of the given examples.
Here's the relevant quote:

Having a function return a constant value is generally inappropriate,
but sometimes doing so can reduce the incidence of client errors with-
out giving up safety or efficiency. For example, consider the declara-
tion of the operator* function for rational numbers that is explored in
Item 24:

Code:

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

Many programmers squint when they first see this. Why should the
result of operator* be a const object? Because if it weren’t, clients
would be able to commit atrocities like this:

Code:

Rational a, b, c;
...
(a * b) = c; // invoke operator= on the result of a*b!

I don’t know why any programmer would want to make an assignment
to the product of two numbers, but I do know that many programmers
have tried to do it without wanting to...

The question is, why is the 'const' necessary in this particular example?
Why isn't:

Code:

Rational operator*(const Rational& lhs, const Rational& rhs);

enough?
This function (without the const) returns an rvalue, which you cannot assign to anyway (compile-time error).
What am I missing here?

It's not an r-value. You can basically fill out Rational and test this yourself, like I did, and see that (a * b) = c; is a legal construct, because of the lack of const correctness.

Here is my gdb output. It's bad enough that we succeeded in a compile, but you can clearly see that the operator* is entered and then the return value, if you could access it anyway, is overwritten.

Code:

Reading symbols from /cygdrive/c/users/josh2/desktop/foo/rational...done.
(gdb) break 6
Breakpoint 1 at 0x4011f2: file main.cpp, line 6.
(gdb) break 4
Breakpoint 2 at 0x40119e: file main.cpp, line 4.
(gdb) run
Starting program: /cygdrive/c/users/josh2/desktop/foo/rational
[New Thread 3492.0x538]
[New Thread 3492.0xc44]

Breakpoint 2, main () at main.cpp:5
5           Rational a(2, 3), b(4, 5), c;
(gdb) rwatch c
Hardware read watchpoint 3: c
(gdb) c
Continuing.

Breakpoint 1, main () at main.cpp:6
6           (a * b) = c;
(gdb) c
Continuing.
Hardware read watchpoint 3: c

Value = {top = 1, bottom = 1}
0x00401212 in main () at main.cpp:6
6           (a * b) = c;
(gdb)

So yes, a const return value is necessary here if you want to avoid a very silly thing.

For some reason I thought that every temporary ("Anonimous varaible") has an expression scope, and can't be the lhs of an assignment...

Whiteflags; it seems like it is an rvalue, but, as phantomotap pointed out, it is legal to change an rvalue.

Consider this class for example:
Rational.h

Code:

class Rational {
public:
    Rational();
    Rational(int nominator);
    Rational(int nominator, int denominator);
    Rational operator*(const Rational& rhs);
    virtual ~Rational();
private:
    int m_nominator;
    int m_denominator;
};

Rational.c

Code:

#include "Rational.h"

// more implamentation here...

Rational Rational::operator *(const Rational& rhs) {
    return Rational((m_nominator*rhs.m_nominator),(m_denominator*rhs.m_denominator));
}

So now, the compiler will allow this:

Code:

int main() {
    Rational a,b,c;
    (a*b)=c;
}

But when I try to bind the return value to a reference (I know it's basically wrong, but I'm doing it for testing purposes) like this:

Rational.h

Code:

class Rational {
public:
    Rational();
    Rational(int nominator);
    Rational(int nominator, int denominator);
    Rational& operator*(const Rational& rhs);
    virtual ~Rational();
private:
    int m_nominator;
    int m_denominator;
};

Rational.c

Code:

#include "Rational.h"

// more implamentation here...

Rational& Rational::operator *(const Rational& rhs) {
    return Rational((m_nominator*rhs.m_nominator),(m_denominator*rhs.m_denominator));
}

I get:
error: invalid initialization of non-const reference of type ‘Rational&’ from an rvalue of type ‘Rational’