Why is this expression illegal?

[Chris Yates]

Why is this illegal:

--(i++) // Error: -- needs an l-value

and this is not:

(--i)++

??

Why is i++ not an l-value but --i is? Pre incrementor adds 1 to the l-value
and returns the l-value, so that explains that. However, I thought i++
would return the l-value and the increment it after the expression?

-
Chris

[Victor Bazarov]

Chris Yates wrote:

Why is this illegal:

--(i++) // Error: -- needs an l-value

and this is not:

(--i)++

??

Why is i++ not an l-value but --i is? Pre incrementor adds 1 to the l-value
and returns the l-value, so that explains that. However, I thought i++
would return the l-value and the increment it after the expression?

Nope. Post-increment returns an r-value. When it increments the actual
object is unspecified.

V

[David Lindauer]

Chris Yates wrote:

Why is this illegal:

--(i++) // Error: -- needs an l-value

and this is not:

(--i)++

??

Why is i++ not an l-value but --i is? Pre incrementor adds 1 to the l-value
and returns the l-value, so that explains that. However, I thought i++
would return the l-value and the increment it after the expression?

if i is say an integer, --i (or ++i) does something before accessing the
variable... whereas i++(or i--) does something after accessing the variable. In
the former case the variable changes before you get its value so everything is
kosher, but in the latter case the variable may change value between the time it
is fetched and the time you use it. (I don't know if it HAS to change
immediately or it can wait till the next sequence point, but there are common
cases where compilers do try to adhere to changing it immediately to make users
happy).

David

[Bob Hairgrove]

On Wed, 03 Nov 2004 22:52:50 GMT, "Chris Yates" <us****@iyates. com>
wrote:

Why is this illegal:

--(i++) // Error: -- needs an l-value

and this is not:

(--i)++

??

Why is i++ not an l-value but --i is? Pre incrementor adds 1 to the l-value
and returns the l-value, so that explains that. However, I thought i++
would return the l-value and the increment it after the expression?

I am not sure, but I believe both expressions lead to undefined
behaviour, RE: the C++ standard, due to the lack of a sequence point
between increment and decrement.

There are some threads on comp.std.c++ about this. Please try to look
at these, as well as the standard itself, for more of an in-depth
explanation. Unfortunately, I don't have the subject lines at hand...

--
Bob Hairgrove
No**********@Ho me.com

[Andrey Tarasevich]

Chris Yates wrote:

Why is this illegal:

--(i++) // Error: -- needs an l-value

and this is not:

(--i)++

??
Both are illegal, but for different reasons. The first one is
ill-formed, the second one causes undefined behavior.
Why is i++ not an l-value but --i is? Pre incrementor adds 1 to the l-value
and returns the l-value, so that explains that. However, I thought i++
would return the l-value and the increment it after the expression?

The C++ language doesn't specify what happens "before" and what happens
"after" in this case. The argument of the post-increment ('i') might get
incremented immediately, it might get incremented "after the
expression", it might get incremented "before the expression" - no one
knows and no one cares, since in any case the result must be the
original value of 'i'. Hence the potential need to take it out of 'i'
and store it "on the side", as an rvalue.

--
Best regards,
Andrey Tarasevich

[Rolf Magnus]

Chris Yates wrote:

Why is this illegal:

--(i++) // Error: -- needs an l-value

and this is not:

(--i)++

??

Why is i++ not an l-value but --i is? Pre incrementor adds 1 to the
l-value
and returns the l-value, so that explains that. However, I thought i++
would return the l-value and the increment it after the expression?

Think about it. How would the operator return something, and _after_ that
change the value? After it returned, it cannot do anything anymore.

[Andre Dajd]

Victor Bazarov <v.********@com Acast.net> wrote in message news:<iC******* *********@newsr ead1.dllstx09.u s.to.verio.net> ...

Chris Yates wrote:

Why is this illegal:

--(i++) // Error: -- needs an l-value

and this is not:

(--i)++

??

Why is i++ not an l-value but --i is? Pre incrementor adds 1 to the l-value
and returns the l-value, so that explains that. However, I thought i++
would return the l-value and the increment it after the expression?

Nope. Post-increment returns an r-value. When it increments the actual
object is unspecified.

Post increment, actually, returns a copy of the original object, which
is created before the original object is modified. Therefore
(offtopic) the postfix operator is, actually, slower.

Standard 5.2.6.

d

[Richard Herring]

In message <10************ *@news.supernew s.com>, Andrey Tarasevich
<an************ **@hotmail.com> writes

Chris Yates wrote:

Why is this illegal:

--(i++) // Error: -- needs an l-value

and this is not:

(--i)++

??
Both are illegal, but for different reasons. The first one is
ill-formed, the second one causes undefined behavior.

Why is i++ not an l-value but --i is? Pre incrementor adds 1 to the l-value
and returns the l-value, so that explains that. However, I thought i++
would return the l-value and the increment it after the expression?

The C++ language doesn't specify what happens "before" and what happens
"after" in this case.

More to the point, nothing in the above says that i has to be of a
built-in type. If the operator is user-defined, there _is_ no "before"
and "after". Everything the operator does must take place _during_ the
call to it. The only way you can get the right semantics for
post-increment within a single function call is to take a copy, then
increment i, then return the copy by value, hence an rvalue.
The argument of the post-increment ('i') might get
incremented immediately, it might get incremented "after the
expression", it might get incremented "before the expression" - no one
knows and no one cares, since in any case the result must be the
original value of 'i'. Hence the potential need to take it out of 'i'
and store it "on the side", as an rvalue.

--
Richard Herring

[Andrey Tarasevich]

Andre Dajd wrote:

...
Nope. Post-increment returns an r-value. When it increments the actual
object is unspecified.
Post increment, actually, returns a copy of the original object, which
is created before the original object is modified.

Incorrect. The notion of "returning a copy" (or simply "returning" ) the
way you use it is not applicable to built-in increment operators.
Therefore (offtopic) the postfix operator is, actually, slower.
True for user-defined operators. Completely untrue for built-in ones.
And we are talking about the latter here.
Standard 5.2.6.

I don't see anything you said in 5.2.6.

--
Best regards,
Andrey Tarasevich

[Andre Dajd]

Andrey Tarasevich <an************ **@hotmail.com> wrote in message news:<10******* ******@news.sup ernews.com>...

Andre Dajd wrote:

...
Nope. Post-increment returns an r-value. When it increments the actual
object is unspecified.
Post increment, actually, returns a copy of the original object, which
is created before the original object is modified.

Incorrect. The notion of "returning a copy" (or simply "returning" ) the
way you use it is not applicable to built-in increment operators.

See first [Note] in the citation below and note world "copy" there.
Fine, I withdraw word "return", as using it in the context requires
abstract thinking beyond repeating C++ Standard's deficiencies.
Mathematically (=abstractly) every operation (mapping) "returns"
something (has image).

Therefore (offtopic) the postfix operator is, actually, slower.

True for user-defined operators. Completely untrue for built-in ones.
And we are talking about the latter here.

Original question did not imply that, neither did any post in this
subthread. Mind your perceptions.

Standard 5.2.6.

I don't see anything you said in 5.2.6.

[expr.post.incr] 5.2.6 Increment and decrement

The value obtained by applying a postfix ++ is the value that the
operand had before applying the operator.
[Note: the value obtained is a copy of the original value ] The
operand shall be a modifiable lvalue. The
type of the operand shall be an arithmetic type or a pointer to a
complete object type. After the result is
noted, the value of the object is modified by adding 1 to it, unless
the object is of type bool, in which case
it is set to true. [Note: this use is deprecated, see annex D. ] The
result is an rvalue. The type of the
result is the cvunqualified
version of the type of the operand. See also 5.7 and 5.17.