How do I send floats in window messages

Question

What is the best way to send a float in a windows message using c++ casting operators?

The reason I ask is that the approach which first occurred to me did not work. For the record I'm using the standard win32 function to send messages:

PostWindowMessage(UINT nMsg, WPARAM wParam, LPARAM lParam)

What does not work:

Using static_cast<WPARAM>() does not work since WPARAM is typedef'ed to UINT_PTR and will do a numeric conversion from float to int, effectively truncating the value of the float.
Using reinterpret_cast<WPARAM>() does not work since it is meant for use with pointers and fails with a compilation error.

I can think of two workarounds at the moment:

Using reinterpret_cast in conjunction with the address of operator:

float f = 42.0f;
::PostWindowMessage(WM_SOME_MESSAGE, *reinterpret_cast<WPARAM*>(&f), 0);

Using an union:

union { WPARAM wParam, float f };
f = 42.0f;
::PostWindowMessage(WM_SOME_MESSAGE, wParam, 0);

Which of these are preffered? Are there any other more elegant way of accomplishing this?

I'd not recommend to send pointers to temporaries via something called "PostWindowMessage" since it is supposed to be asynchronous. — Kirill V. Lyadvinsky, Mar 23 '10 at 09:51
The pointer is dereferenced at the call (the star before the cast), no temporary address is sent to PostWindowMessage — Vincent Robert, Mar 23 '10 at 10:09
@Kirill I'm not sending pointers to temporaries. I'm taking the address of the float, casting that address to a pointer to a WPARAM and resolving that address into a WPARAM which gets passed by value. The pointers are only used to trick the compiler into not converting the value. — Yngve Hammersland, Mar 23 '10 at 10:10

score 3 · Accepted Answer · answered Mar 23 '10 at 10:04

3

Use reinterpret_cast< WPARAM &>(f). This cast is not restricted to pointers, it also works with references.

answered Mar 23 '10 at 10:04

MSalters

score 2 · Answer 2 · 2010-03-23T10:04:42.293

2

You could use memcpy:

#include <memory.h>
int main() {
    float f = 1.0;
    int n;
    memcpy( &n, &f, sizeof(f) );
}

I don't think there is an elegant solution to this, but whatever you do, I'd wrap it in a function to make it obvious what I was up to:

int FloatToInt( float f ) {
    int n;
    assert( sizeof(n) == sizeof(f) );
    memcpy( &n, &f, sizeof(f) );
    return n;
}

edited Mar 23 '10 at 10:04

answered Mar 23 '10 at 09:40

+1 This is the safest way to do it. In theory using `reinterpret_cast` the way the OP does is undefined behaviour, although in practice it will probably work... – Andreas Brinck Mar 23 '10 at 09:46
I'd add `if ( sizeof float == sizeof int )` – Kirill V. Lyadvinsky Mar 23 '10 at 09:53
@Kirill I wouldn't, but I might add an assertion. – Mar 23 '10 at 10:03
1

`WPARAM` is hardly a portable type. I don't think this case needs even an assertion. On Win32 and Win64, floats are no bigger than pointers, and it's entirely reasonable to assume the same for Win128. – MSalters Mar 23 '10 at 10:08
In this answer `FloatToInt` returns `int` and not `WPARAM`. – Kirill V. Lyadvinsky Mar 23 '10 at 10:14

score 1 · Answer 3 · answered Mar 23 '10 at 10:01

1

I would prefer the union. It is the clearest and easiest to understand. It also probably has the least amount of undefined behavior.

answered Mar 23 '10 at 10:01

Gabe

Heh, nicely put: "least amount of undefined behaviour". :P – Yngve Hammersland Mar 23 '10 at 10:11
1

Using the union in this way (saving in one member and reading from another) evokes undefined behavior. – John Dibling Mar 23 '10 at 12:42
Please review [this post](https://stackoverflow.com/a/22026484/4975230), type punning is defined behavior in C, but not in C++. Something like `memcpy` is probably safer than the equivalent union code. – jrh Dec 26 '17 at 15:24

score 0 · Answer 4 · answered Mar 23 '10 at 14:35

0

I'd go the simple way of taking a pointer to your float, casting it to a pointer to UINT, and then dereferencing the resulting pointer:

WPARAM wParam = *((UINT*)(&f));

To convert it back you do the opposite. Doing the cast at pointer-level makes sure the compiler won't try any "conversion" behind your back.

float f = *((float*)(&wParam))

answered Mar 23 '10 at 14:35

Koro

This answer is very likely to be okay, [because Visual Studio doesn't have strict aliasing](https://stackoverflow.com/questions/37176461/does-visual-c-support-strict-aliasing), but this sort of trick will fail if you try this on a compiler that supports [strict aliasing](https://stackoverflow.com/questions/98650/what-is-the-strict-aliasing-rule) like GCC. So this is probably fine for win32, but don't make this a habit for cross platform code. – jrh Dec 26 '17 at 15:34

4 Answers4