I understand why c = c++; can be undefined. Modification twice within a
single sequence point, so if c is originally 9, we can do the ++c
modification before or after the = modification, and thus get results 10
or 9.

But what about c = ++c; is this also undefined?

Just guessing, I would say it depends on how we define ++c. Do we say that
++c means "first make modification to c, then evaluate c", in which case
c = ++c; where c was first 9 should always assign c the value 10.

or does ++c mean "the evaluation of the expression ++c is c+1. c still at
this point can (if it wants to) retain its value of 9. ie the
modification can take place anytime, just make sure the evaluation is the
value HAD it been modified." If so, then there would be two possibilities:

c = 9;
c = ++c;

1. first c is 9. Then an assignment of c+1 (10) is assigned to c; then ++c
is done, making c 11.
2. first c is 9. Then we evaluate ++c to be 10. Then we modify c from the
++c, so c is now 10. Then we assign 10 to c, so c is 10.

So which one is it?

Josh Waxman

[snip]

[-                               firewind                                   -]

[-          "You're just jealous because the voices talk to -me-."          -]
[-                   Have a good day, and enjoy your C.                     -]
[-          (on a crusade of grumpiness where grumpiness is due)            -]

1) We can take the value of c add one and assign the result to d, now
the compiler can go back and actually increment the value of c.
2) We can increment the value of c then assign it to d.

One might assume that any compiler publisher will do the first but this
might not be the best way to do it on every single architecture.

3) We can take the value of c pass it to one processor which increments
it and assigns it to d, and pass c itself to a second processor for
incrementing its value.

The real point is that the C standard does not assume anything about the
processor.  It lets the compiler produce the optimum code for the
architecture regardless.

Besides, under any circumstances a simple

        c++;

works every time.  c gets incremented and retains the value.

--
****************************************************************
What is the speed of dark?
When you're sending someone Styrofoam, what do you pack it in?
Why are there Braille signs on drive-up ATM's?
How come you never hear about gruntled employees?
I have an answering machine in my car.
    It says "I'm home now.
    But leave a message and I'll call when I'm out."
=========================================

=========================================
READ THE FAQ for more information:
   C-FAQ ftp sites: ftp://ftp.eskimo.com or ftp://rtfm.mit.edu
   Hypertext C-FAQ: http://www.eskimo.com/~scs/C-faq/top.html

On Mon, 15 Dec 1997 19:54:55 -0500, Joshua Waxman

See: http://www.eskimo.com/~scs/C-faq/top.html.

==
Miguel Carrasquer Vidal                     ~ ~
Amsterdam                   _____________  ~ ~

========================== Ce .sig n'est pas une .cig

Here are the sequence points:
* just before calling a function, after the arguments are evaluated
* after evaluating the left-hand operand of &&, ||, ?: or ,
* at the semicolon marking the end of a statement
* at the end of an initialiser
* the end of the controlling expression of if, switch, while or do/while
* the end of each of the three expressions in a for statement
* the end of the expression in a return statement

Now, none of these is present inside the expression 'c = c++', so
the result is undefined.  'c' could come to have the value 42, or
your program could crash, or it could trash some part of your
operating system.

That's the language lawyer's answer.

There are probably compilers somewhere, too, which interpret this in
some weird and wonderful way you've never even dreamed of.  Because
the compiler writers just don't have to worry about what happens
if you do 'c = ++c'.

That's the pragmatist's answer.

Whichever answer you prefer, it doesn't affect the fact that 'c = ++c'
is just plain wrong.

Hope that helps.

Cheers,
Richard
--
Richard Stamp
Churchill College, Cambridge

...

--
-----------------------------------------


-----------------------------------------

   c = c = 1;

is undefined. It is undefined because the C standard says so. But just in
case you think that c = ++c; should always increment c by one, an example
of a very widespread implementation where this is not the case:

Assume that the compiler knows how to produce the best possible code for x
= ++y; and that the compiler will produce the same code for c = ++c;

On the PowerPC computers, if x and y are both in registers, the best
possible code for x = ++y; is

   add   x,y,1    /* x = y + 1 */
   add   y,y,1    /* y = y + 1 */

because both adds are independent and can be done at the same time (one
cycle). The more obvious looking

   add   y,y,1    /* y = y + 1 */
   mr    x,y      /* x = y */

is slower because the second instruction has to wait until the first one
is finished (takes two cycles).

So a reasonable compiler could produce the following code for c = ++c;

   add   c,c,1    /* c = c + 1 */
   add   c,c,1    /* c = c + 1 */

Which I'm afraid, brings me back to my first question.  What's the
point?

Phil Christensen