Bit Pattern Problem

[fb]

Hi Everyone. Thanks for the help with the qudratic equation problem...I
didn't think about actually doing the math...whoops. Anyway... I'm
having some trouble getting the following program to work. I want to
output a bit pattern from base 10 input. All I get is a zero after the
input...I've looked over the code but can't see the problem...any ideas?
/* display the bit pattern corresponding to
a signed decimal integer */

#include<stdio. h>
#include<stdlib .h>

int main(void)
{
int a, b, m, count, nbits;
unsigned mask;

/* determine the word size in bits and set the initial mask */
nbits = 8 * sizeof(int);
m = 0x1 << (nbits - 1); /* Place 1 in leftmost position */

/* main loop */
do {
/* read a signed integer */
printf("\n\nEnt er an integer value (0 to stop): ", a);
scanf("%d", &a);

/* output the bit pattern */
mask = m;
for(count = 1; count <= nbits; count++); {
b = (a & mask) ? 1 : 0; /* set display bit on or off */
printf("%x", b); /* print display bit */
if (count % 4 == 0)
printf(" "); /* blank space after ever 4th digit */
mask >>= 1; /* shift mask 1 position to the right */
}
} while (a != 0);
return EXIT_SUCCESS; /* If it's there why not use it people! */
}

[junky_fellow]

rl*@hoekstra-uitgeverij.nl (Richard Bos) wrote in message news:<41******* **********@news .individual.net >...

ju**********@ya hoo.co.in (junky_fellow) wrote:

"Arthur J. O'Dwyer" <aj*@nospam.and rew.cmu.edu> wrote in message news:<Pi******* *************** ************@un ix49.andrew.cmu .edu>...

On Mon, 6 Sep 2004, Barry Schwarz wrote:

> d = b*b-4*a*c;
> if (d>0) ... The result of the assignment operator is discarded. It never gets
used. What gets used in the 'if' statement is the value of the object
'd'. (That 'd' was assigned to in the previous statement has absolutely
no relevance.)
Can you please elaborate why the result of assignment operator is
discarded ?

Because there's nowhere for it to go to. The statement has finished.

i even test the above condition by writing a program,
but the behaviour was as expected. The value assigned to 'd' was
not discarded.

No, but that's not the same value. It _has_ the same value, but it's not
the same value. Perhaps another example is in order. Say,

x = y = 5;

You'll agree that this is one statement, consisting of two assignment
operations, right? Ok, first of all, = binds to the right, so x = y = 5
is x = (y = 5), not (x = y) = 5. With that in mind, what happens is:

- 5 is evaluated. Its value is, no surprise there, 5.
- the right assignment operation assigns the value of its right operand,
5, to its left operand, y, which now also has the value of 5.

If y is a volatile variable, and its value gets changed at this point,
then which value will be assigned to x, new value of y or 5 ?

- The right assignment operation _also_ passes the value of its right
operand on, up the evaluation tree.
- The left assignment operation assigns the value of its right
operand, which just happens to be the value of the right assignment,
which in turn is the value of _its_ right operand, which was 5 (ok,
enough whiches already!), to its left operand, x. Now x also has
a value of 5.
Note that by this time the value of y does not matter any more. If y
is volatile, and gets changed behind the program's back between the
two assignments, that does not matter a jot. What gets assigned to x
is _not_ the value of y, but the value of the right assignment.
- The right assignment also passes the value of its right operand up the
evaluation tree.
- Since there is no further operator to use this value, however, it is
discarded. The statement is now complete, and there is a sequence
point here.

So, when and where such scenarios would cause undefined behaviour.

In very convoluted situations, since you need to access a temporary
value in a previous statement, which has already finished. I'm not even
sure Christian's example is valid ISO C; even if it is, it's not _good_
ISO C.

Richard

[Dan Pop]

In <8c************ **************@ posting.google. com> ju**********@ya hoo.co.in (junky_fellow) writes:

If y is a volatile variable, and its value gets changed at this point,
then which value will be assigned to x, new value of y or 5 ?

Do yourself a favour and read a tutorial C book.

Dan
--
Dan Pop
DESY Zeuthen, RZ group
Email: Da*****@ifh.de
Currently looking for a job in the European Union

[Richard Bos]

ju**********@ya hoo.co.in (junky_fellow) wrote:

rl*@hoekstra-uitgeverij.nl (Richard Bos) wrote in message news:<41******* **********@news .individual.net >...

- the right assignment operation assigns the value of its right operand,
5, to its left operand, y, which now also has the value of 5.

If y is a volatile variable, and its value gets changed at this point,
then which value will be assigned to x, new value of y or 5 ?

Did you even read anything after this point? For example, this:

Note that by this time the value of y does not matter any more. If y
is volatile, and gets changed behind the program's back between the
two assignments, that does not matter a jot. What gets assigned to x
is _not_ the value of y, but the value of the right assignment.

Richard

[lawrence.jones]

Richard Bos <rl*@hoekstra-uitgeverij.nl> wrote:

- The right assignment operation _also_ passes the value of its right
operand on, up the evaluation tree.

Not quite, it passes the new value of its left operand up the tree. It
makes a difference if there is an implicit conversion during the
assignment. For example:

float f;
int i;

f = i = 2.5;

The value assigned to f is 2, not 2.5. Note that it's the value after
assignment that's passed on, not necessarily the current value, so if i
were volatile, the compiler would not be obliged to re-read it to
determine the value.

-Larry Jones

It doesn't have a moral, does it? I hate being told how to live my life.
-- Calvin

[junky_fellow]

rl*@hoekstra-uitgeverij.nl (Richard Bos) wrote in message news:<41******* **********@news .individual.net >...

ju**********@ya hoo.co.in (junky_fellow) wrote:

rl*@hoekstra-uitgeverij.nl (Richard Bos) wrote in message news:<41******* **********@news .individual.net >...

- the right assignment operation assigns the value of its right operand,
5, to its left operand, y, which now also has the value of 5.

If y is a volatile variable, and its value gets changed at this point,
then which value will be assigned to x, new value of y or 5 ?

Did you even read anything after this point? For example, this:

I had read the lines many times before asking that question.
i had in my mind that the value assigned to x should be the new value
of y and not the 5, in case it gets changed behind the program's back.
i don't think that the compiler will reread the previous value (i.e. 5 again).
after it gets changed.

Note that by this time the value of y does not matter any more. If y
is volatile, and gets changed behind the program's back between the
two assignments, that does not matter a jot. What gets assigned to x
is _not_ the value of y, but the value of the right assignment.

Richard

[Mark Piffer]

so************@ yahoo.com (Mark Piffer) wrote in message news:<cc******* *************** ****@posting.go ogle.com>...

Christian Bau <ch***********@ cbau.freeserve. co.uk> wrote in message news:<ch******* *************** ***********@slb-newsm1.svr.pol. co.uk>...

In article <ch************ *************@t heriver.com>,
Barry Schwarz <sc******@deloz .net> wrote:

Could someone please explain what section 6.5.16-4 means

"The order of evaluation of the operands is unspecified. If an attempt
is made to modify the result of an assignment operator or to access it
after the next sequence point, the behavior is undefined."

You have to do some pretty weird things to
"access the result of an assignment operator":

typedef struct { int x [3]; } mystruct;
mystruct a, b;
int* p;

p = &(a = b).x[2];
*p = 3;

Normally, if you have
int i = 3, j = 4;
i = j;

the result of the assignment operator is not "j", and it is not "i", but
the number 4. In the example above, the "result of the assignment
operator" is a value of type mystruct, but it is not a or b. I managed
to get the address of an element of that struct into p; p is not equal
to &a.x[2] or &b.x[2]. The assignment *p = 3; is undefined behavior.

Ok, how about the following:
int a,b,c;
int f(int);

if( (a=b) == f(c) ) { // undefined behaviour?
}

As the order of execution is unspecified (is it?), the evaluation sequence could be:
[1] a=b
[2] f(c) // sequence point (according to 6.5.2.2/10)
[3] == // using the result of [1] and [2]

Does some other rule catch this construct?

Mark

Can someone enlighten me about this? Either I got ignored or the
posting vanished too soon from the servers, but I think the question
isn't trivial (ok, for regulars here maybe it is) and certainly not
OT.

regards,
Mark

[Flash Gordon]

On 9 Sep 2004 03:57:19 -0700
so************@ yahoo.com (Mark Piffer) wrote:

so************@ yahoo.com (Mark Piffer) wrote in message
news:<cc******* *************** ****@posting.go ogle.com>...

<snip>

Ok, how about the following:
int a,b,c;
int f(int);

if( (a=b) == f(c) ) { // undefined behaviour?
}

As the order of execution is unspecified (is it?), the evaluation
sequence could be:[1] a=b
[2] f(c) // sequence point (according to 6.5.2.2/10)
[3] == // using the result of [1] and [2]

Does some other rule catch this construct?

Mark

Can someone enlighten me about this? Either I got ignored or the
posting vanished too soon from the servers, but I think the question
isn't trivial (ok, for regulars here maybe it is) and certainly not
OT.

The order of evaluation of a=b and f(c) does not affect the result in
this case, so why would it be undefined behaviour? Admittedly the value
of a might not be updated until after the comparison has been done, but
the comparison still has to be done against the correct value.

If you had:
if ((c=b)==f(c))
or:
if ((a=c)==f(c))
you would have undefined behaviour.
--
Flash Gordon
Sometimes I think shooting would be far too good for some people.
Although my email address says spam, it is real and I read it.

[pete]

pete wrote:

a = atoi(string);

a = (int)strtol(str ing, NULL, 10);

would avoid undefined behavior.

--
pete

[Dan Pop]

In <qs************ @brenda.flash-gordon.me.uk> Flash Gordon <sp**@flash-gordon.me.uk> writes:

On 9 Sep 2004 03:57:19 -0700
so************ @yahoo.com (Mark Piffer) wrote:

so************@ yahoo.com (Mark Piffer) wrote in message
news:<cc******* *************** ****@posting.go ogle.com>...
<snip>

> Ok, how about the following:
> int a,b,c;
> int f(int);
>
> if( (a=b) == f(c) ) { // undefined behaviour?
> }
>
> As the order of execution is unspecified (is it?), the evaluation
> sequence could be:[1] a=b
> [2] f(c) // sequence point (according to 6.5.2.2/10)
> [3] == // using the result of [1] and [2]
>
> Does some other rule catch this construct?
>
> Mark

Can someone enlighten me about this?
Try posting to comp.std.c to improve your chances of getting some
enlightenment. Your analysis looks correct to me: for no good reason,
6.5.16p4 renders the behaviour of your example undefined.
Either I got ignored or the
posting vanished too soon from the servers, but I think the question
isn't trivial (ok, for regulars here maybe it is) and certainly not
OT.

The order of evaluation of a=b and f(c) does not affect the result in
this case, so why would it be undefined behaviour?

Because 6.5.16p4 (quoted in Mark's post) says so.
Admittedly the value
of a might not be updated until after the comparison has been done, but
the comparison still has to be done against the correct value.
The value of a was updated in the problematic scenario. See the
evaluation order posted by Mark.
If you had:
if ((c=b)==f(c))
or:
if ((a=c)==f(c))
you would have undefined behaviour.

I can see no additional problems in your second example. Why would be it
any different from Mark's example?

Dan
--
Dan Pop
DESY Zeuthen, RZ group
Email: Da*****@ifh.de
Currently looking for a job in the European Union

[CBFalconer]

Flash Gordon wrote:

.... snip ...
If you had:
if ((c=b)==f(c))
Yes
or:
if ((a=c)==f(c))
No.
you would have undefined behaviour.

In the latter case c is being accessed only to extract its value,
not to alter it. Assuming it is not a volatile value.

--
"Churchill and Bush can both be considered wartime leaders, just
as Secretariat and Mr Ed were both horses." - James Rhodes.
"We have always known that heedless self-interest was bad
morals. We now know that it is bad economics" - FDR