Re: lvalue required as increment operand -- why does the Standard requires this for fundamental types only?

From:

SG <s.gesemann@gmail.com>

Newsgroups:

comp.lang.c++

Date:

Sat, 2 Jul 2011 10:43:21 -0700 (PDT)

Message-ID:

<ea790f08-0c40-4125-b91d-ee3310ef59b4@fr19g2000vbb.googlegroups.com>

On 2 Jul., 19:30, Pavel wrote:

What is the rationale for this lvalue requirement if there is one?

-----------------
int f1() { return 5; }

class Int {
public:
   explicit Int(int i) : i_(i) {}
   Int & operator++() { ++i_; return *this; }
private:
   int i_;
};

Int f2() { return Int(5); }

int main(int, char *[]) {
//int i1 = ++f1(); (void)i1; // this does not compile
   Int i2 = ++f2(); (void)i2; // this compiles fine
   return 0;

Why do you even want the first one to compile? f1 simply returns a
value. If you want f1()+1 then write f1()+1. There is abolutely no
reason to support prefix ++ on things that don't refer to any object.
Check the C++ standard w.r.t. the C++ object model and lvalue/rvalue
expressions. You'll see that an rvalue of type int does NOT refer to
an object whereas an rvalue of type Int _does_ refer to an object
because Int is a class type. Now, why does C++ allow you to invoke a
nonconst member function on a temporary object? Answer: Why not? It
may be useful. Whether you overloaded an operator or wrote a function
with some other name does not matter. Your overloaded operator++ could
have other side effects which would make ++f2() do something useful.

Cheers!
SG