Velocity Reviews > What does that operation mean?

# What does that operation mean?

Al
Guest
Posts: n/a

 09-26-2006
Hi,
can anyone tell me what the following means? x is a float, and j an
integer. What value is in j afterwards?

j=0; j=(int)(x)&512;

Now if I use 128 instead of 512 what's the difference?

Thanks,
Al

Chris Dollin
Guest
Posts: n/a

 09-26-2006
Al wrote:

> can anyone tell me what the following means?

for help.

> x is a float, and j an
> integer. What value is in j afterwards?
>
> j=0; j=(int)(x)&512;

We don't know what float value `x` has, so we don't know what
int value `(int)(x)` has (this could be written as `(int) x`),
so we don't know what value `(int) x & 512` has, except that
it's either 0 or 512, because of the way bitwise-& works.

There's no point in assigning `0` to `j` and then assigning
it the other value.

Don't post incomplete fragments.

> Now if I use 128 instead of 512 what's the difference?

The answer's either 0 or 128.

--
Chris "all to pieces, bits and pieces" Dollin
I'm full of sweetness and light. And I'm /keeping/ it.

Frederick Gotham
Guest
Posts: n/a

 09-26-2006
Al posted:

> j=(int)(x)&512;

The value of the expression, "x", is converted to int, and then BitwiseAND'ed
with the integer value 512.

--

Frederick Gotham

Jack Klein
Guest
Posts: n/a

 09-26-2006
On Tue, 26 Sep 2006 10:08:25 +0100, Chris Dollin <(E-Mail Removed)>
wrote in comp.lang.c:

> Al wrote:
>
> > can anyone tell me what the following means?

>
> for help.
>
> > x is a float, and j an
> > integer. What value is in j afterwards?
> >
> > j=0; j=(int)(x)&512;

>
> We don't know what float value `x` has, so we don't know what
> int value `(int)(x)` has (this could be written as `(int) x`),
> so we don't know what value `(int) x & 512` has, except that
> it's either 0 or 512, because of the way bitwise-& works.

No, it's undefined, and anything can happen. Accessing the value of
an uninitialized float produces the undefined behavior. Attempting to
cast to int and performing a bit-wise and has nothing to do with it,
the wheels have already fallen off before you get that far.

> The answer's either 0 or 128.

There is no answer here, either, since the behavior is still
undefined.

--
Jack Klein
Home: http://JK-Technology.Com
FAQs for
comp.lang.c http://c-faq.com/
comp.lang.c++ http://www.parashift.com/c++-faq-lite/
alt.comp.lang.learn.c-c++
http://www.contrib.andrew.cmu.edu/~a...FAQ-acllc.html

Jack Klein
Guest
Posts: n/a

 09-26-2006
On Tue, 26 Sep 2006 20:54:15 GMT, Frederick Gotham
<(E-Mail Removed)> wrote in comp.lang.c:

> Al posted:
>
> > j=(int)(x)&512;

>
>
> The value of the expression, "x", is converted to int, and then BitwiseAND'ed
> with the integer value 512.

Accessing the uninitialized value of the float x causes undefined
behavior. What happens after that doesn't matter, at least not here.

--
Jack Klein
Home: http://JK-Technology.Com
FAQs for
comp.lang.c http://c-faq.com/
comp.lang.c++ http://www.parashift.com/c++-faq-lite/
alt.comp.lang.learn.c-c++
http://www.contrib.andrew.cmu.edu/~a...FAQ-acllc.html

Old Wolf
Guest
Posts: n/a

 09-27-2006
Chris Dollin wrote:
> Al wrote:
> > x is a float, and j an integer. What value is in j afterwards?
> > j=0; j=(int)(x)&512;

>
> We don't know what float value `x` has, so we don't know what
> int value `(int)(x)` has (this could be written as `(int) x`),
> so we don't know what value `(int) x & 512` has, except that
> it's either 0 or 512, because of the way bitwise-& works.

If 'x' has a value outside the range of int, then the behaviour
is undefined. Otherwise it is 0 or 512

Jack Klein wrote:
> No, it's undefined, and anything can happen. Accessing the value of
> an uninitialized float produces the undefined behavior.

What makes you think x is uninitialized?

Chris Dollin
Guest
Posts: n/a

 09-27-2006
Jack Klein wrote:

> On Tue, 26 Sep 2006 10:08:25 +0100, Chris Dollin <(E-Mail Removed)>
> wrote in comp.lang.c:
>
>> > x is a float, and j an
>> > integer. What value is in j afterwards?
>> >
>> > j=0; j=(int)(x)&512;

>>
>> We don't know what float value `x` has, so we don't know what
>> int value `(int)(x)` has (this could be written as `(int) x`),
>> so we don't know what value `(int) x & 512` has, except that
>> it's either 0 or 512, because of the way bitwise-& works.

>
> No, it's undefined, and anything can happen. Accessing the value of
> an uninitialized float produces the undefined behavior.

Good catch. I was rather assuming that his `x` had been given
/a/ value somewhere: I should have said so. (I did wonder if
the irrelevant `j=0;` was a typo for `x=0;`.)

--
Chris "`x` marks the nasal demon" Dollin
RIP John M. Ford (April 10, 1957 -- September 24, 2006)

Kenny McCormack
Guest
Posts: n/a

 09-30-2006
In article <(E-Mail Removed)>,
Jack Klein <(E-Mail Removed)> wrote:
>On Tue, 26 Sep 2006 20:54:15 GMT, Frederick Gotham
><(E-Mail Removed)> wrote in comp.lang.c:
>
>> Al posted:
>>
>> > j=(int)(x)&512;

>>
>>
>> The value of the expression, "x", is converted to int, and then BitwiseAND'ed
>> with the integer value 512.

>
>Accessing the uninitialized value of the float x causes undefined
>behavior. What happens after that doesn't matter, at least not here.

What makes you think that x is uninitialized?

Just because you can't see it in the posted fragment, doesn't mean you
can assume that the posted fragment is the entire program. In fact, we
can be sure that the posted fragment is *not* the entire program, since
it would not compile as is.