## digitalmars.D - Why isn't ++x an lvalue in D?

• Bill Baxter (7/7) Jan 08 2009 Another thread just reminded me of something I use frequently in C++
• Weed (17/26) Jan 08 2009 ++x is x+=1 in D:
• Bill Baxter (13/13) Jan 08 2009 MjAwOS8xLzkgV2VlZCA8cmVzdW1lNzU1QG1haWwucnU+Ogo+IEJpbGwgQmF4dGVyINDJ28XU...
• Weed (13/51) Jan 08 2009 I am a bit mixed, but the meaning has not changed:
• Weed (5/59) Jan 08 2009 And I think it is wrong that the ++ same as += 1. The operator ++ in C
• Bill Baxter (27/27) Jan 08 2009 T24gRnJpLCBKYW4gOSwgMjAwOSBhdCAyOjQzIFBNLCBXZWVkIDxyZXN1bWU3NTVAbWFpbC5y...
• Weed (4/67) Jan 08 2009 Thus, once it works it is necessary to change anything if only for the
• Don (8/75) Jan 09 2009 There is none. In tango.math.Math there's nextFloatUp, nextDoubleUp,
• Bill Baxter (25/25) Jan 08 2009 T24gRnJpLCBKYW4gOSwgMjAwOSBhdCAyOjIyIFBNLCBXZWVkIDxyZXN1bWU3NTVAbWFpbC5y...
• Weed (4/66) Jan 08 2009
• Nick Sabalausky (5/56) Jan 08 2009 Shouldn't that be "(i += 1) %= N"? Assignments are right-associative (bu...
• Weed (3/66) Jan 08 2009 Yes, my code is wrongÀ
"Bill Baxter" <wbaxter gmail.com> writes:
```Another thread just reminded me of something I use frequently in C++
that doesn't work in D because ++x is not an lvalue:

int x,N;
...
++x %= N;

So is there some deep reason for not making it an lvalue like in C++?

--bb
```
Jan 08 2009
Weed <resume755 mail.ru> writes:
```Bill Baxter ÐÉÛÅÔ:
Another thread just reminded me of something I use frequently in C++
that doesn't work in D because ++x is not an lvalue:

int x,N;
...
++x %= N;

So is there some deep reason for not making it an lvalue like in C++?

++x is x+=1 in D:

void main() {
int i =3;
int N =2;
(i+=1) %= N;
}

Error: i += 1 is not an lvalue.

C++:

int main()
{
int i = 2;
int N = 3;
i+1 %= N;

return 0;
}

error: lvalue required as left operand of assignment
```
Jan 08 2009
"Bill Baxter" <wbaxter gmail.com> writes:
```MjAwOS8xLzkgV2VlZCA8cmVzdW1lNzU1QG1haWwucnU+Ogo+IEJpbGwgQmF4dGVyINDJ28XUOgo+
PiBBbm90aGVyIHRocmVhZCBqdXN0IHJlbWluZGVkIG1lIG9mIHNvbWV0aGluZyBJIHVzZSBmcmVx
dWVudGx5IGluIEMrKwo+PiB0aGF0IGRvZXNuJ3Qgd29yayBpbiBEIGJlY2F1c2UgKyt4IGlzIG5v
dCBhbiBsdmFsdWU6Cj4+Cj4+ICAgIGludCB4LE47Cj4+ICAgLi4uCj4+ICAgICsreCAlPSBOOwo+
Pgo+PiBTbyBpcyB0aGVyZSBzb21lIGRlZXAgcmVhc29uIGZvciBub3QgbWFraW5nIGl0IGFuIGx2
YWx1ZSBsaWtlIGluIEMrKz8KPj4KPgo+ICsreCBpcyB4Kz0xIGluIEQ6Cj4KPiB2b2lkIG1haW4o
KSB7Cj4gIGludCBpID0zOwo+ICBpbnQgTiA9MjsKPiAgKGkrPTEpICU9IE47Cj4gfQo+Cj4KPiBF
cnJvcjogaSArPSAxIGlzIG5vdCBhbiBsdmFsdWUuCj4KPiBDKys6Cj4KPiBpbnQgbWFpbigpCj4g
ewo+ICBpbnQgaSA9IDI7Cj4gIGludCBOID0gMzsKPiAgaSsxICU9IE47Cj4KPiAgcmV0dXJuIDA7
Cj4gfQo+Cj4gZXJyb3I6IGx2YWx1ZSByZXF1aXJlZCBhcyBsZWZ0IG9wZXJhbmQgb2YgYXNzaWdu
bWVudAo+CgpXaGF0IGRvZXMgQysrIGRvIGlmIHlvdSB1c2UgIChpKz0xKSAlPSBOIGluc3RlYWQg
b2YgKGkrMSk/ICBEb2Vzbid0ICs9CmFsc28gcmV0dXJuIGFuIGx2YWx1ZSBpbiBDKys/CgotLWJi
Cg==
```
Jan 08 2009
Weed <resume755 mail.ru> writes:
```Bill Baxter Ð¿Ð¸ÑˆÐµÑ‚:
2009/1/9 Weed <resume755 mail.ru>:
Bill Baxter Ð¿Ð¸ÑˆÐµÑ‚:
Another thread just reminded me of something I use frequently in C++
that doesn't work in D because ++x is not an lvalue:

int x,N;
...
++x %= N;

So is there some deep reason for not making it an lvalue like in C++?

++x is x+=1 in D:

void main() {
int i =3;
int N =2;
(i+=1) %= N;
}

Error: i += 1 is not an lvalue.

C++:

int main()
{
int i = 2;
int N = 3;
i+1 %= N;

return 0;
}

error: lvalue required as left operand of assignment

What does C++ do if you use  (i+=1) %= N instead of (i+1)?  Doesn't +=
also return an lvalue in C++?

I am a bit mixed, but the meaning has not changed:

\$ cat demo.cpp
int main()
{
int i = 2;
int N = 3;
i+=1 %= N;

return 0;
}

\$ c++ demo.cpp
demo.cpp: In function â€˜int main()â€™:
demo.cpp:5: error: lvalue required as left operand of assignment
```
Jan 08 2009
Weed <resume755 mail.ru> writes:
```Weed Ð¿Ð¸ÑˆÐµÑ‚:
Bill Baxter Ð¿Ð¸ÑˆÐµÑ‚:
2009/1/9 Weed <resume755 mail.ru>:
Bill Baxter Ð¿Ð¸ÑˆÐµÑ‚:
Another thread just reminded me of something I use frequently in C++
that doesn't work in D because ++x is not an lvalue:

int x,N;
...
++x %= N;

So is there some deep reason for not making it an lvalue like in C++?

++x is x+=1 in D:

void main() {
int i =3;
int N =2;
(i+=1) %= N;
}

Error: i += 1 is not an lvalue.

C++:

int main()
{
int i = 2;
int N = 3;
i+1 %= N;

return 0;
}

error: lvalue required as left operand of assignment

What does C++ do if you use  (i+=1) %= N instead of (i+1)?  Doesn't +=
also return an lvalue in C++?

I am a bit mixed, but the meaning has not changed:

\$ cat demo.cpp
int main()
{
int i = 2;
int N = 3;
i+=1 %= N;

return 0;
}

\$ c++ demo.cpp
demo.cpp: In function â€˜int main()â€™:
demo.cpp:5: error: lvalue required as left operand of assignment

And I think it is wrong that the ++ same as += 1. The operator ++ in C
uniquely compiles in CPU instruction "increment".

For objects it would be better to make a += 1 only if undefined
```
Jan 08 2009
"Bill Baxter" <wbaxter gmail.com> writes:
```T24gRnJpLCBKYW4gOSwgMjAwOSBhdCAyOjQzIFBNLCBXZWVkIDxyZXN1bWU3NTVAbWFpbC5ydT4g
d3JvdGU6Cj4gV2VlZCDQydvF1DoKPj4gQmlsbCBCYXh0ZXIg0MnbxdQ6Cj4+PiAyMDA5LzEvOSBX
ZWVkIDxyZXN1bWU3NTVAbWFpbC5ydT46Cj4+Pj4gQmlsbCBCYXh0ZXIg0MnbxdQ6Cj4+Pj4+IEFu
b3RoZXIgdGhyZWFkIGp1c3QgcmVtaW5kZWQgbWUgb2Ygc29tZXRoaW5nIEkgdXNlIGZyZXF1ZW50
bHkgaW4gQysrCj4+Pj4+IHRoYXQgZG9lc24ndCB3b3JrIGluIEQgYmVjYXVzZSArK3ggaXMgbm90
IGFuIGx2YWx1ZToKPj4+Pj4KPj4+Pj4gICAgaW50IHgsTjsKPj4+Pj4gICAuLi4KPj4+Pj4gICAg
Kyt4ICU9IE47Cj4+Pj4+Cj4+Pj4+IFNvIGlzIHRoZXJlIHNvbWUgZGVlcCByZWFzb24gZm9yIG5v
dCBtYWtpbmcgaXQgYW4gbHZhbHVlIGxpa2UgaW4gQysrPwo+Pj4+Pgo+Pj4+ICsreCBpcyB4Kz0x
IGluIEQ6Cj4+Pj4KPj4+PiB2b2lkIG1haW4oKSB7Cj4+Pj4gIGludCBpID0zOwo+Pj4+ICBpbnQg
TiA9MjsKPj4+PiAgKGkrPTEpICU9IE47Cj4+Pj4gfQo+Pj4+Cj4+Pj4KPj4+PiBFcnJvcjogaSAr
PSAxIGlzIG5vdCBhbiBsdmFsdWUuCj4+Pj4KPj4+PiBDKys6Cj4+Pj4KPj4+PiBpbnQgbWFpbigp
Cj4+Pj4gewo+Pj4+ICBpbnQgaSA9IDI7Cj4+Pj4gIGludCBOID0gMzsKPj4+PiAgaSsxICU9IE47
Cj4+Pj4KPj4+PiAgcmV0dXJuIDA7Cj4+Pj4gfQo+Pj4+Cj4+Pj4gZXJyb3I6IGx2YWx1ZSByZXF1
aXJlZCBhcyBsZWZ0IG9wZXJhbmQgb2YgYXNzaWdubWVudAo+Pj4+Cj4+PiBXaGF0IGRvZXMgQysr
IGRvIGlmIHlvdSB1c2UgIChpKz0xKSAlPSBOIGluc3RlYWQgb2YgKGkrMSk/ICBEb2Vzbid0ICs9
Cj4+PiBhbHNvIHJldHVybiBhbiBsdmFsdWUgaW4gQysrPwo+Pgo+PiBJIGFtIGEgYml0IG1peGVk
LCBidXQgdGhlIG1lYW5pbmcgaGFzIG5vdCBjaGFuZ2VkOgo+Pgo+PiAkIGNhdCBkZW1vLmNwcAo+
PiBpbnQgbWFpbigpCj4+IHsKPj4gIGludCBpID0gMjsKPj4gIGludCBOID0gMzsKPj4gIGkrPTEg
JT0gTjsKPj4KPj4gIHJldHVybiAwOwo+PiB9Cj4+Cj4+ICQgYysrIGRlbW8uY3BwCj4+IGRlbW8u
Y3BwOiBJbiBmdW5jdGlvbiAnaW50IG1haW4oKSc6Cj4+IGRlbW8uY3BwOjU6IGVycm9yOiBsdmFs
dWUgcmVxdWlyZWQgYXMgbGVmdCBvcGVyYW5kIG9mIGFzc2lnbm1lbnQKPgo+IEFuZCBJIHRoaW5r
IGl0IGlzIHdyb25nIHRoYXQgdGhlICsrIHNhbWUgYXMgKz0gMS4gVGhlIG9wZXJhdG9yICsrIGlu
IEMKPiB1bmlxdWVseSBjb21waWxlcyBpbiBDUFUgaW5zdHJ1Y3Rpb24gImluY3JlbWVudCIuCj4K
PiBGb3Igb2JqZWN0cyBpdCB3b3VsZCBiZSBiZXR0ZXIgdG8gbWFrZSBhICs9IDEgb25seSBpZiB1
bmRlZmluZWQKPiBvdmVybG9hZGVkIG9wZXJhdG9yICsrLgoKWWVoLCBJIHRoaW5rIHRoYXQncyBz
Y2hlZHVsZWQgdG8gYmUgY2hhbmdlZCBhZnRlciBBbmRyZWkncyByZXBlYXRlZAp0aHJhc2hpbmdz
IG9mIFdhbHRlci4KCi0tYmIK
```
Jan 08 2009
Weed <resume755 mail.ru> writes:
```Bill Baxter ÐÉÛÅÔ:
On Fri, Jan 9, 2009 at 2:43 PM, Weed <resume755 mail.ru> wrote:
Weed ÐÉÛÅÔ:
Bill Baxter ÐÉÛÅÔ:
2009/1/9 Weed <resume755 mail.ru>:
Bill Baxter ÐÉÛÅÔ:
Another thread just reminded me of something I use frequently in C++
that doesn't work in D because ++x is not an lvalue:

int x,N;
...
++x %= N;

So is there some deep reason for not making it an lvalue like in C++?

++x is x+=1 in D:

void main() {
int i =3;
int N =2;
(i+=1) %= N;
}

Error: i += 1 is not an lvalue.

C++:

int main()
{
int i = 2;
int N = 3;
i+1 %= N;

return 0;
}

error: lvalue required as left operand of assignment

What does C++ do if you use  (i+=1) %= N instead of (i+1)?  Doesn't +=
also return an lvalue in C++?

I am a bit mixed, but the meaning has not changed:

\$ cat demo.cpp
int main()
{
int i = 2;
int N = 3;
i+=1 %= N;

return 0;
}

\$ c++ demo.cpp
demo.cpp: In function 'int main()':
demo.cpp:5: error: lvalue required as left operand of assignment

And I think it is wrong that the ++ same as += 1. The operator ++ in C
uniquely compiles in CPU instruction "increment".

For objects it would be better to make a += 1 only if undefined

Yeh, I think that's scheduled to be changed after Andrei's repeated
thrashings of Walter.

Thus, once it works it is necessary to change anything if only for the
real types increment will give increase for the lowest possible value.
(I do not know how the CPU instruction increment works for real values)
```
Jan 08 2009
Don <nospam nospam.com> writes:
```Weed wrote:
Bill Baxter ÐÉÛÅÔ:
On Fri, Jan 9, 2009 at 2:43 PM, Weed <resume755 mail.ru> wrote:
Weed ÐÉÛÅÔ:
Bill Baxter ÐÉÛÅÔ:
2009/1/9 Weed <resume755 mail.ru>:
Bill Baxter ÐÉÛÅÔ:
Another thread just reminded me of something I use frequently in C++
that doesn't work in D because ++x is not an lvalue:

int x,N;
...
++x %= N;

So is there some deep reason for not making it an lvalue like in C++?

++x is x+=1 in D:

void main() {
int i =3;
int N =2;
(i+=1) %= N;
}

Error: i += 1 is not an lvalue.

C++:

int main()
{
int i = 2;
int N = 3;
i+1 %= N;

return 0;
}

error: lvalue required as left operand of assignment

What does C++ do if you use  (i+=1) %= N instead of (i+1)?  Doesn't +=
also return an lvalue in C++?

I am a bit mixed, but the meaning has not changed:

\$ cat demo.cpp
int main()
{
int i = 2;
int N = 3;
i+=1 %= N;

return 0;
}

\$ c++ demo.cpp
demo.cpp: In function 'int main()':
demo.cpp:5: error: lvalue required as left operand of assignment

And I think it is wrong that the ++ same as += 1. The operator ++ in C
uniquely compiles in CPU instruction "increment".

For objects it would be better to make a += 1 only if undefined

Yeh, I think that's scheduled to be changed after Andrei's repeated
thrashings of Walter.

Thus, once it works it is necessary to change anything if only for the
real types increment will give increase for the lowest possible value.
(I do not know how the CPU instruction increment works for real values)

There is none. In tango.math.Math there's nextFloatUp, nextDoubleUp,
nextRealUp, which perform the "next possible number" operation.
In D, ++x for real x performs x = x + 1.0.
If x is (say) 1e80, then (++x) == x !

I'm not sure why D allows ++x for floating-point types, it's asking for
trouble IMHO -- if you're incrementing a real, I think it's highly
probable that you have a bug somewhere.
```
Jan 09 2009
"Bill Baxter" <wbaxter gmail.com> writes:
```T24gRnJpLCBKYW4gOSwgMjAwOSBhdCAyOjIyIFBNLCBXZWVkIDxyZXN1bWU3NTVAbWFpbC5ydT4g
d3JvdGU6Cj4gQmlsbCBCYXh0ZXIg0MnbxdQ6Cj4+IDIwMDkvMS85IFdlZWQgPHJlc3VtZTc1NUBt
YWlsLnJ1PjoKPj4+IEJpbGwgQmF4dGVyINDJ28XUOgo+Pj4+IEFub3RoZXIgdGhyZWFkIGp1c3Qg
cmVtaW5kZWQgbWUgb2Ygc29tZXRoaW5nIEkgdXNlIGZyZXF1ZW50bHkgaW4gQysrCj4+Pj4gdGhh
dCBkb2Vzbid0IHdvcmsgaW4gRCBiZWNhdXNlICsreCBpcyBub3QgYW4gbHZhbHVlOgo+Pj4+Cj4+
Pj4gICAgaW50IHgsTjsKPj4+PiAgIC4uLgo+Pj4+ICAgICsreCAlPSBOOwo+Pj4+Cj4+Pj4gU28g
aXMgdGhlcmUgc29tZSBkZWVwIHJlYXNvbiBmb3Igbm90IG1ha2luZyBpdCBhbiBsdmFsdWUgbGlr
ZSBpbiBDKys/Cj4+Pj4KPj4+ICsreCBpcyB4Kz0xIGluIEQ6Cj4+Pgo+Pj4gdm9pZCBtYWluKCkg
ewo+Pj4gIGludCBpID0zOwo+Pj4gIGludCBOID0yOwo+Pj4gIChpKz0xKSAlPSBOOwo+Pj4gfQo+
Pj4KPj4+Cj4+PiBFcnJvcjogaSArPSAxIGlzIG5vdCBhbiBsdmFsdWUuCj4+Pgo+Pj4gQysrOgo+
Pj4KPj4+IGludCBtYWluKCkKPj4+IHsKPj4+ICBpbnQgaSA9IDI7Cj4+PiAgaW50IE4gPSAzOwo+
Pj4gIGkrMSAlPSBOOwo+Pj4KPj4+ICByZXR1cm4gMDsKPj4+IH0KPj4+Cj4+PiBlcnJvcjogbHZh
bHVlIHJlcXVpcmVkIGFzIGxlZnQgb3BlcmFuZCBvZiBhc3NpZ25tZW50Cj4+Pgo+Pgo+PiBXaGF0
IGRvZXMgQysrIGRvIGlmIHlvdSB1c2UgIChpKz0xKSAlPSBOIGluc3RlYWQgb2YgKGkrMSk/ICBE
b2Vzbid0ICs9Cj4+IGFsc28gcmV0dXJuIGFuIGx2YWx1ZSBpbiBDKys/Cj4KPiBJIGFtIGEgYml0
IG1peGVkLCBidXQgdGhlIG1lYW5pbmcgaGFzIG5vdCBjaGFuZ2VkOgo+Cj4gJCBjYXQgZGVtby5j
cHAKPiBpbnQgbWFpbigpCj4gewo+ICBpbnQgaSA9IDI7Cj4gIGludCBOID0gMzsKPiAgaSs9MSAl
PSBOOwo+Cj4gIHJldHVybiAwOwo+IH0KPgo+ICQgYysrIGRlbW8uY3BwCj4gZGVtby5jcHA6IElu
IGZ1bmN0aW9uICdpbnQgbWFpbigpJzoKPiBkZW1vLmNwcDo1OiBlcnJvcjogbHZhbHVlIHJlcXVp
cmVkIGFzIGxlZnQgb3BlcmFuZCBvZiBhc3NpZ25tZW50Cj4KCkh1aC4gIE9rLCB3ZWxsIEkgZ3Vl
c3MgdGhhdCBhbnN3ZXJzIGl0IHRoZW4uICBUaGFua3MuICBNeXN0ZXJ5IHNvbHZlZCEKVG8gc3Vt
bWFyaXplLCBJbiBEICAgKyt4IGlzIHgrPTEsIGFuZCBpbiBELCBsaWtlIGluIEMrKywgIHgrPTEg
aXMgbm90CmFuIGx2YWx1ZS4gICBHb3QgaXQuCgpCdXQgbm93IEkgd29uZGVyIHdoeSBpdCdzIG5v
dCBhbiBsdmFsdWUgaW4gQysrIG9yIEQuICBJZiB4PXkgaXMgYW4KbHZhbHVlIGFuZCArK3ggaXMg
YW4gbHZhbHVlLCB3aHkgc2hvdWxkbid0IHgrPTEgYmUgb25lIHRvbz8KCi0tYmIK
```
Jan 08 2009
Weed <resume755 mail.ru> writes:
```Bill Baxter ÐÉÛÅÔ:
On Fri, Jan 9, 2009 at 2:22 PM, Weed <resume755 mail.ru> wrote:
Bill Baxter ÐÉÛÅÔ:
2009/1/9 Weed <resume755 mail.ru>:
Bill Baxter ÐÉÛÅÔ:
Another thread just reminded me of something I use frequently in C++
that doesn't work in D because ++x is not an lvalue:

int x,N;
...
++x %= N;

So is there some deep reason for not making it an lvalue like in C++?

++x is x+=1 in D:

void main() {
int i =3;
int N =2;
(i+=1) %= N;
}

Error: i += 1 is not an lvalue.

C++:

int main()
{
int i = 2;
int N = 3;
i+1 %= N;

return 0;
}

error: lvalue required as left operand of assignment

What does C++ do if you use  (i+=1) %= N instead of (i+1)?  Doesn't +=
also return an lvalue in C++?

I am a bit mixed, but the meaning has not changed:

\$ cat demo.cpp
int main()
{
int i = 2;
int N = 3;
i+=1 %= N;

return 0;
}

\$ c++ demo.cpp
demo.cpp: In function 'int main()':
demo.cpp:5: error: lvalue required as left operand of assignment

Huh.  Ok, well I guess that answers it then.  Thanks.  Mystery solved!
To summarize, In D   ++x is x+=1, and in D, like in C++,  x+=1 is not
an lvalue.   Got it.

But now I wonder why it's not an lvalue in C++ or D.  If x=y is an
lvalue and ++x is an lvalue, why shouldn't x+=1 be one too?

It is also a lvalue, it is my mistake again.

(i+=1) %= N;
```
Jan 08 2009
"Nick Sabalausky" <a a.a> writes:
```"Weed" <resume755 mail.ru> wrote in message
news:gk6n29\$218m\$1 digitalmars.com...
Bill Baxter ?????:
2009/1/9 Weed <resume755 mail.ru>:
Bill Baxter ?????:
Another thread just reminded me of something I use frequently in C++
that doesn't work in D because ++x is not an lvalue:

int x,N;
...
++x %= N;

So is there some deep reason for not making it an lvalue like in C++?

++x is x+=1 in D:

void main() {
int i =3;
int N =2;
(i+=1) %= N;
}

Error: i += 1 is not an lvalue.

C++:

int main()
{
int i = 2;
int N = 3;
i+1 %= N;

return 0;
}

error: lvalue required as left operand of assignment

What does C++ do if you use  (i+=1) %= N instead of (i+1)?  Doesn't +=
also return an lvalue in C++?

I am a bit mixed, but the meaning has not changed:

\$ cat demo.cpp
int main()
{
int i = 2;
int N = 3;
i+=1 %= N;

Shouldn't that be "(i += 1) %= N"? Assignments are right-associative (but
then these are op-assigns...). The error is probably saying that "1" can't
be an lvalue for "%= N" which, of course, is true.

return 0;
}

\$ c++ demo.cpp
demo.cpp: In function 'int main()':
demo.cpp:5: error: lvalue required as left operand of assignment

```
Jan 08 2009
Weed <resume755 mail.ru> writes:
```Nick Sabalausky ÐÉÛÅÔ:
"Weed" <resume755 mail.ru> wrote in message
news:gk6n29\$218m\$1 digitalmars.com...
Bill Baxter ?????:
2009/1/9 Weed <resume755 mail.ru>:
Bill Baxter ?????:
Another thread just reminded me of something I use frequently in C++
that doesn't work in D because ++x is not an lvalue:

int x,N;
...
++x %= N;

So is there some deep reason for not making it an lvalue like in C++?

++x is x+=1 in D:

void main() {
int i =3;
int N =2;
(i+=1) %= N;
}

Error: i += 1 is not an lvalue.

C++:

int main()
{
int i = 2;
int N = 3;
i+1 %= N;

return 0;
}

error: lvalue required as left operand of assignment

What does C++ do if you use  (i+=1) %= N instead of (i+1)?  Doesn't +=
also return an lvalue in C++?

I am a bit mixed, but the meaning has not changed:

\$ cat demo.cpp
int main()
{
int i = 2;
int N = 3;
i+=1 %= N;

Shouldn't that be "(i += 1) %= N"? Assignments are right-associative (but
then these are op-assigns...). The error is probably saying that "1" can't
be an lvalue for "%= N" which, of course, is true.

Yes, my code is wrongÀ

And apparently, we have an error in D

return 0;
}

\$ c++ demo.cpp
demo.cpp: In function 'int main()':
demo.cpp:5: error: lvalue required as left operand of assignment

```
Jan 08 2009