Is it safe to change this c-cast to a reinterpret_cast?

Question

I'm trying to remove a c-style cast from some code I'm working on, and I have concerns about the only alternative.

The original code was:

WPARAM param = (WPARAM)(GetDlgItem(IDC_WORKFLOW).m_hWnd);
this->PostMessage(WM_NEXTDLGCTL, param, TRUE);

If I use a static cast:

WPARAM param = static_cast<WPARAM>(GetDlgItem(IDC_WORKFLOW).m_hWnd);
this->PostMessage(WM_NEXTDLGCTL, param, TRUE);

I get the error, 'static_cast' : cannot convert from 'HWND' to 'WPARAM', because there's no valid conversion between the underlying types. This leaves me with "the devil's option":

WPARAM param = reinterpret_cast<WPARAM>(GetDlgItem(IDC_WORKFLOW).m_hWnd);
this->PostMessage(WM_NEXTDLGCTL, param, TRUE);

As I understand it, if a static_cast is impossible, and this isn't related to constness, the C-cast must be doing a reinterpret_cast anyway, which means that the underlying code must be casting back, which means this is safe (point 3 in remarks). But I'd like to confirm this, before just changing the code.

Is this cast safe in this specific instance, and how do I confirm this? If not, what is the alternative?

Yes it is safe, however you can just keep using C-style cast which is common in Windows API / MFC code, and IMO, is easier to read. — dsi, Feb 13 '14 at 12:00
@MichaelFoukarakis WPARAM is guaranteed to be the same width as a pointer, so no problem here — dsi, Feb 13 '14 at 12:03
@dsi I dislike using C-Style because it hides the bad thing you're doing, but thanks for pointing out that it is a common pattern in the codebase I'm working with. — deworde, Feb 13 '14 at 12:07
@dsi Incidentally, could you make that an answer? If nothing better than that comes up, it'd be a "good enough" for anyone searching for this kind of question. — deworde, Feb 13 '14 at 12:09

score 5 · Accepted Answer · answered Feb 13 '14 at 12:16

5

It is safe, because WPARAM is defined as:

typedef UINT_PTR            WPARAM;

and _PTR suffix means the type is big enough to hold a pointer.

while HWND is:

 typedef HANDLE HWND;

where HANDLE is:

typedef void *HANDLE;

so size of void* and UINT_PTR are always the same. If you would store it in 64bit application and try read in 32 bit application, then you would get in trouble.

if you are still concenred if that is safe to do such casts, you can search Visual Studio sources (in C:\Program Files (x86)\Microsoft Visual Studio 8\ folder), and you will find lots of lines with reinterpret_cast<LPARAM>(...) and reinterpret_cast<WPARAM>(...).

answered Feb 13 '14 at 12:16

marcinj

48,511
9
79
100

3

You can safely store 64 bits HWND in 32 bits types. See http://stackoverflow.com/questions/18266626/what-is-windows-handle-range-on-a-64-bits-application – manuell Feb 13 '14 at 14:47
1

If `STRICT` is defined then `HWND` is a typedef for `struct HWND__*` instead of `HANDLE`/`void*`. – Remy Lebeau Feb 13 '14 at 17:17
@RemyLebeau yes, but its still a pointer value, no one is dereferencing HWND. The whole DECLARE_HANDLE is only to add some typesafety to windows handles. – marcinj Feb 13 '14 at 17:28

score 2 · Answer 2 · answered Feb 13 '14 at 12:10

2

Yes, this is fine, and is what reinterpret_cast is intended for, ie the "trust me I know what I'm doing" approach that C has to casting.

answered Feb 13 '14 at 12:10

Sean

60,939
11
97
136

score 1 · Answer 3 · answered Jul 14 '20 at 01:02

1

maybe now we can use std::bit_cast from C++20 as an alternative way, which should be more well-behaved.

under the hood, std::bit_cast uses std::memcpy, which I think you can also use to cast from HWND to WPARAM

answered Jul 14 '20 at 01:02

haohaolee

677
1
9
16

score 0 · Answer 4 · answered Feb 13 '14 at 12:24

0

It might work on your computer, with your compiler, and with a very specific set of compilation options for your compiler.

You are casting one pointer type to another. That is not "safe". Your code is violating the strict aliasing rule. This enables your compiler to interpret your code in ways very different from what you intended. Your code might work, it might not. You are invoking undefined behavior.

answered Feb 13 '14 at 12:24

David Hammen

32,454
9
60
108

While true, in this specific instance, as other answers have said, this is the only way to achieve the result needed. – deworde Feb 13 '14 at 13:32
Also, it's not undefined. The behaviour is well-defined for the basic "cast-to-X", "cast-back-from-X", which is what reinterpret_cast is for. Actually *using* the WPARAM without casting back to a handle is an entirely different matter, which is why I asked the question. – deworde Feb 13 '14 at 13:36

score 0 · Answer 5 · answered Feb 13 '14 at 12:27

No as a general rule. The C style cast will try to do what is right. This normally means trying a static_cast and only if this is impossible doing a reinterpret_cast

Take a look at the following C++ code

#include <stdio.h> 
#include <new>

class Base
{
public:
    int base;
};

class Extension
{
public:
    int extension;
};

class Derived : public Base, public Extension
{
public:
    int derived;
};

int main()
{
    Derived* der = new Derived;
    der->base = 1;
    der->extension = 2;
    der->derived = 3;

    Extension* ext = (Extension*)der;
    printf ("The value of ext->extension = %d\n",ext->extension);
    ext = reinterpret_cast<Extension*>(der);  
    printf ("The value of ext->extension = %d\n",ext->extension);
}

The results are

c:\work>test
The value of ext->extension = 2    
The value of ext->extension = 1

In other words it is not safe to blindly replace C style casts with reinterpret_casts.

Thanks and good answer for the general case, but I'm aware of the risks of what I termed "the devil's option", I'm asking about this specific case, so that I'm **not** doing it blindly. — deworde, Feb 13 '14 at 13:33

Is it safe to change this c-cast to a reinterpret_cast?

5 Answers5

Linked