convert a double keeping msb ?

[DanSteph]

hello all,

I have a problem, I have a DOUBLE value like that

4065 4000 0000 0000

and I want to convert it to a DWORD like that:
4065 4000

if I do result=(DWORD)M yDouble it end with AA(170)
wich I don't want.

Believe me or not but I spent 4 hours on this,
I cannot shift the bits, the compiler complaint with double,
it say: "bad left operand" "bad right operand" while it work
well with DWORD.

I'm puzzled, any help appreciated (VC++ 5.0)

Dan

[John Harrison]

"DanSteph" <Da******@caram ail.com> wrote in message
news:40******** **************@ news.free.fr...

hello all,

I have a problem, I have a DOUBLE value like that

4065 4000 0000 0000

and I want to convert it to a DWORD like that:
4065 4000

if I do result=(DWORD)M yDouble it end with AA(170)
wich I don't want.

Believe me or not but I spent 4 hours on this,
I cannot shift the bits, the compiler complaint with double,
it say: "bad left operand" "bad right operand" while it work
well with DWORD.

I'm puzzled, any help appreciated (VC++ 5.0)

Dan

Like this (this is not portable code)

double x = ...;
DWORD msb = *(DWORD*)&x;

if that doesn't work try

DWORD msb = *((DWORD*)&x + 1);

In either case the trick is doing the conversion via a pointer. That avoids
the compiler converting a double value to a DWORD value.

john

[Denis Remezov]

John Harrison wrote:

"DanSteph" <Da******@caram ail.com> wrote in message
news:40******** **************@ news.free.fr...

hello all,

I have a problem, I have a DOUBLE value like that

4065 4000 0000 0000

and I want to convert it to a DWORD like that:
4065 4000

if I do result=(DWORD)M yDouble it end with AA(170)
wich I don't want.

Believe me or not but I spent 4 hours on this,
I cannot shift the bits, the compiler complaint with double,
it say: "bad left operand" "bad right operand" while it work
well with DWORD.

I'm puzzled, any help appreciated (VC++ 5.0)

Dan

Like this (this is not portable code)

double x = ...;
DWORD msb = *(DWORD*)&x;

if that doesn't work try

DWORD msb = *((DWORD*)&x + 1);

It is DWORD msb = *((DWORD*)&x + 1); on little endian machines
(e.g. PC).

This one got me thinking: is the result of the above undefined
or implementation-defined behaviour (assuming the size of double
and DWORD as above)? There are two things that I am unsure
about: adjusting a reinterpret_cas t-ed pointer and dereferencing
the resulting value. As far as I know, neither is explicitly
condoned. Just a theoretical interest.

Denis

[John Harrison]

> >

Like this (this is not portable code)

double x = ...;
DWORD msb = *(DWORD*)&x;

if that doesn't work try

DWORD msb = *((DWORD*)&x + 1);

It is DWORD msb = *((DWORD*)&x + 1); on little endian machines
(e.g. PC).

This one got me thinking: is the result of the above undefined
or implementation-defined behaviour (assuming the size of double
and DWORD as above)? There are two things that I am unsure
about: adjusting a reinterpret_cas t-ed pointer and dereferencing
the resulting value. As far as I know, neither is explicitly
condoned. Just a theoretical interest.

Denis

Its the sort of thing that the standard is really bad at explaining. I
believe that it is undefined behaviour (on both counts) because I've seen
others claim that in this group, I couldn't point you to the sections of the
standard to back that up.

Copying to an array of char is explicitly allowed by the standard however,
so if the OP was concerned about UB then he should copy the double to an
array of char and construct the DWORD from that.

john

[DanSteph]

Many thanks for your replies,

I finaly woke up in the midle of the night (couln't sleep)
of course pointer was the solution, So I finaly went with that:

DWORD* Ptrweightshort= (DWORD*)&FsStat ionCrew[0].Weight; // this is double
Ptrweightshort+ =1;
DWORD weightshort=*Pt rweightshort;

Nothing as elegant as somes of your solutions but it work.
I'll now try yours.

Many thanks again

Dan

[Bill Seurer]

John Harrison wrote:

Like this (this is not portable code)

double x = ...;
DWORD msb = *(DWORD*)&x;

if that doesn't work try

DWORD msb = *((DWORD*)&x + 1);

It is DWORD msb = *((DWORD*)&x + 1); on little endian machines
(e.g. PC).

This one got me thinking: is the result of the above undefined
or implementation-defined behaviour (assuming the size of double
and DWORD as above)? There are two things that I am unsure
about: adjusting a reinterpret_cas t-ed pointer and dereferencing
the resulting value. As far as I know, neither is explicitly
condoned. Just a theoretical interest.

Its the sort of thing that the standard is really bad at explaining. I
believe that it is undefined behaviour (on both counts) because I've seen
others claim that in this group, I couldn't point you to the sections of the
standard to back that up.

It is bad because of aliasing rules. I don't know what a "DWORD" is but
unless it is somehow related to double the code is not correct.
The C++ aliasing rules are something like this:

If the program attempts to access the stored value of an object through
an lvalue of other than one of the following types the behavior is
undefined:

1. the dynamic type of the object,
2. a cv-qualified version of the declared type of the object,
3. a type that is the signed or unsigned type corresponding to the
declared type of the object,
4. a type that is the signed or unsigned type corresponding to a
cv-qualified version of the declared type of the object,
5. an aggregate or union type that includes one of the
aforementioned types among its members (including, recursively, a member
of a subaggregate or contained union),
6. a type that is a (possibly cv-qualified) base class type of the
declared type of the object,
7. a char or unsigned char type.

[Julie]

Bill Seurer wrote:

It is bad because of aliasing rules. I don't know what a "DWORD" is but
unless it is somehow related to double the code is not correct.

DWORD is a double-word (double meaning 2, not double as in double precision
float) in Windows, which is defined as a 32-bit unsigned integral type.

[John Harrison]

"Bill Seurer" <se****@us.ibm. com> wrote in message
news:cb******** **@news.rchland .ibm.com...

John Harrison wrote:

Like this (this is not portable code)

double x = ...;
DWORD msb = *(DWORD*)&x;

if that doesn't work try

DWORD msb = *((DWORD*)&x + 1);
It is DWORD msb = *((DWORD*)&x + 1); on little endian machines
(e.g. PC).

This one got me thinking: is the result of the above undefined
or implementation-defined behaviour (assuming the size of double
and DWORD as above)? There are two things that I am unsure
about: adjusting a reinterpret_cas t-ed pointer and dereferencing
the resulting value. As far as I know, neither is explicitly
condoned. Just a theoretical interest.
Its the sort of thing that the standard is really bad at explaining. I
believe that it is undefined behaviour (on both counts) because I've seen others claim that in this group, I couldn't point you to the sections of the standard to back that up.

It is bad because of aliasing rules. I don't know what a "DWORD" is but
unless it is somehow related to double the code is not correct.

Its unsigned long.

The C++ aliasing rules are something like this:

If the program attempts to access the stored value of an object through
an lvalue of other than one of the following types the behavior is
undefined:

1. the dynamic type of the object,
2. a cv-qualified version of the declared type of the object,
3. a type that is the signed or unsigned type corresponding to the
declared type of the object,
4. a type that is the signed or unsigned type corresponding to a
cv-qualified version of the declared type of the object,
5. an aggregate or union type that includes one of the
aforementioned types among its members (including, recursively, a member
of a subaggregate or contained union),
6. a type that is a (possibly cv-qualified) base class type of the
declared type of the object,
7. a char or unsigned char type.

Could you give me the C++ standard section? I looked up aliasing in the
index but it didn't help.

john

[Prateek R Karandikar]

"DanSteph" <Da******@caram ail.com> wrote in message news:<40******* *************** @news.free.fr>. ..

hello all,

I have a problem, I have a DOUBLE value like that

4065 4000 0000 0000

and I want to convert it to a DWORD like that:
4065 4000

if I do result=(DWORD)M yDouble it end with AA(170)
wich I don't want.

Believe me or not but I spent 4 hours on this,
I cannot shift the bits, the compiler complaint with double,
it say: "bad left operand" "bad right operand" while it work
well with DWORD.

I'm puzzled, any help appreciated (VC++ 5.0)

Dan

Neither the Standard Library nor the language has any type with the
name "DWORD". If this is your own type, post the definition.

-- --
Abstraction is selective ignorance.
-Andrew Koenig
-- --

[Bill Seurer]

John Harrison wrote:

"Bill Seurer" <se****@us.ibm. com> wrote in message
news:cb******** **@news.rchland .ibm.com...

1. the dynamic type of the object,
2. a cv-qualified version of the declared type of the object,
3. a type that is the signed or unsigned type corresponding to the
declared type of the object,
4. a type that is the signed or unsigned type corresponding to a
cv-qualified version of the declared type of the object,
5. an aggregate or union type that includes one of the
aforementione d types among its members (including, recursively, a member
of a subaggregate or contained union),
6. a type that is a (possibly cv-qualified) base class type of the
declared type of the object,
7. a char or unsigned char type.

Could you give me the C++ standard section? I looked up aliasing in the
index but it didn't help.

In the April 1995 working paper (which I qouted above) it was section
5.0, paragraph 13