16

Why does the following compile in C++?

int phew = 53; ++++++++++phew ;

The same code fails in C, why?

Improve this question
2
  • Adding C++0x tag just for fun. :) Commented Sep 11, 2010 at 15:10
  • 2
    There must be a standard question we can reference for this type of question. So all questions (that we get this time of year from new college students) can just be quickly closed and marked read this. Commented Sep 11, 2010 at 16:04

2 Answers 2

Reset to default
28

Note: The two defect reports DR#637 and DR#222 are important to understand the below's behavior rationale.

For explanation, in C++0x there are value computations and side effects. A side effect for example is an assigment, and a value computation is determining what an lvalue refers to or reading the value out of an lvalue. Note that C++0x has no sequence points anymore and this stuff is worded in terms of "sequenced before" / "sequenced after". And it is stated that

If a side effect on a scalar object is unsequenced relative to either another side effect on the same scalar object or a value computation using the value of the same scalar object, the behavior is undefined.

++v is equivalent to v += 1 which is equivalent to v = v + 1 (except that v is only evaluated once). This yields to ++ (v = v + 1) which I will write as inc = inc + 1, where inc refers to the lvalue result of v = v + 1.

In C++0x ++ ++v is not undefined behavior because for a = b the assignment is sequenced after value computation of b and a, but before value computation of the assignment expression. It follows that the asignment in v = v + 1 is sequenced before value computation of inc. And the assignment in inc = inc + 1 is sequenced after value computation of inc. In the end, both assignments will thus be sequenced, and there is no undefined behavior.

Improve this answer
Sign up to request clarification or add additional context in comments.

21 Comments

Good answer. Similarly int a=4; ++a=5; would not invoke UB in C++0x, right?
@Johannes: I don't understand why a = ++a does not invoke undefined behavior, but a = a++ does. What happened to "except where noted, the order of evaluation of operands of individual operators and subexpressions of individual expressions, and the order in which side effects take place, is unspecified"?
@Daniel, the second does invoke undefined behavior because the modification to a in "a++" is not sequenced before, but after the value computation of "a++" (naturally, because you want it to yield the old value). Thus the assignment and the modification in "a++" is not sequenced relative to each other. The text you quoted is now worded as "Except where noted, evaluations of operands of individual operators and of subexpressions of individual expressions are unsequenced."
@Prasoon, the modification to a in "a++" is sequenced after value computation of "a++". The two a's in "a + a++" are not sequenced in any way, neither their value computations, nor their side effects. So you have a side effect (modification to a) that is unsequenced relative to a value computation to that a (the first operand), and so you have UB.
a = a++; the steps involved are a) value computation of lvalue of 'a' (lhs) b) value computation of lvalue of 'a' (rhs), c) side effect of ++, d) side effect of assignment. Do you mean that in C++0x steps (d) and (c) are unsequenced?
|
15

That is because in C++ pre-increment operator returns an lvalue and it requires its operand to be an lvalue.

++++++++++phew ; in interpreted as ++(++(++(++(++phew))))

However your code invokes Undefined Behaviour because you are trying to modify the value of phew more than once between two sequence points.

In C, pre-increment operator returns an rvalue and requires its operand to be an lvalue. So your code doesn't compile in C mode.

Improve this answer

11 Comments

@Prasoon: Not to second guess you, I am just curious to read about what you said; "you are trying to modify the value of phew more than once between two sequence points". Can you provide an annotation to this part of the standard so I can read more about this?
@Merlyn Morgan-Graham : Read this article by Steve Summit: c-faq.com/expr/seqpoints.html .
Just to be clear, ++++i is well-defined for user-defined types, right?
@FredOverflow: Yes because function call introduces a sequence point. :)
This is only UB in C++03 though. It's valid in C++0x.
|

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.