Re: Very simple question

From:

Michael DOUBEZ <michael.doubez@free.fr>

Newsgroups:

comp.lang.c++

Date:

Tue, 11 Sep 2007 09:46:11 +0200

Message-ID:

<46e645ed$0$28508$426a34cc@news.free.fr>

Jerry Coffin a ?crit :

In article <1189428205.280920.285540@r34g2000hsd.googlegroups.com>,
DenisSolovov@gmail.com says...

I have very simple question, look at next expression:
int b = 0;
int c = 0;
int d = b+++++c;

Due to the 'maximum munch" rule, this is lexed as:

int d = b ++ ++ + c;

It has nothing to do with the "maximum munch", it is because
post-increment has a higher precedence than plus and pre-increment.

See http://www.cppreference.com/operator_precedence.html.

Since the first '++' returns an rvalue, the second one can't work, and
the expression doesn't compile.

If you want to be perverse, you can define a type for which ++ returns
an lvalue, and allow similar code to compile for that type:

class EVIL_LEAKY {
    int value;
public:
    EVIL_LEAKY(int v=0) : value(v) {}

    EVIL_LEAKY &operator++(int) {
        EVIL_LEAKY *temp = new EVIL_LEAKY;
        temp->value=value;
        value++;
        return *temp;
    }
    operator int() { return value; }
};

Or without leak:

struct myInt
{
     myInt(int i=0):i_(i){}

     myInt& operator++(int){myInt r(*this);++i_;return r;}

     operator int()const{return i_;}

     private:
         int i_;
};

pre-increment is a bit more tricky because you have to play with consteness.

Michael