Which one to use when static_cast and reinterpret_cast have the same effect?

Question

Often, especially in Win32 programming it is required to cast from one opaque type to another. For example:

 HFONT font = cast_here<HFONT>( ::GetStockObject( SYSTEM_FONT ) );

Both static_cast and reinterpret_cast are applicable here and have exactly the same effect since HFONT is a pointer to a dummy struct specifically introduced for defining HFONT and HGDIOBJ returned by GetStockObject() is a void* pointer.

Which one - static_cast or reinterpret_cast - is preferable?

Answer 1

static_cast is always preferable, avoid doing reinterpret_casts unless absolutely neccessary.

reinterpret_cast is the least typesafe cast.

More information at this website about which casts should be used when.

Answer 2

static_cast would be preferred.

From More Effective C++ by Scott Meyers

This operator [reinterpret_cast] is used to perform type conversions whose result is nearly always implementation-defined. As a result, reinterpret_casts are rarely portable.

The most common use of reinterpret_cast is to cast between function pointer types.

Answer 3

Since reinterpret_cast is implementation defined, my rule of thumb is: "static_cast where I can, reinterpret_cast where I must".

(other casts aside)

Answer 4

I think static_cast would be preferable. Here's another stack overflow post that has some more discussion about that as well.

Answer 5

It's not correct to state the the casts will have the same affect. The casts do two completely different things:

• static_cast<T>(x) says convert expression x to type T.
• reinterpret_cast<T*>(&x) says interpret the memory location '&x' as a T*

Consider the following:

struct A1 { int a1; };
struct A2 { int a2; };
struct B : public A1, public A2 {};

void foo (A1 * a1, A2 * a2)
{
  B * b1_a1 = static_cast<B*> (a1);
  B * b2_a1 = reinterpret_cast<B*> (a1);
  B * b1_a2 = static_cast<B*> (a2);
  B * b2_a2 = reinterpret_cast<B*> (a2);

  std::cout << "b1_a1==b1_a2" << (b1_a1==b1_a2) << std::endl;
  std::cout << "b2_a1==b2_a2" << (b2_a1==b2_a2) << std::endl;
}

int main ()
{
  B b;
  foo (&b, &b);
}

This program results in the following output:

g++ -o t t.cc ; ./t
b1_a1==b1_a2: 1
b2_a1==b2_a2: 0

This shows how the static_cast from a2 to b2 correctly adjusted the pointer so that it points to the beginning of b, but the reinterpret_cast did not.

Answer 6

My normal advice:

reinterpret_cast<> is to be used only as a last resort. You're telling the compiler to throw away all caution, 'remove all the safeties', and trust your word that it is really Ok, no matter what the compiler knows about the code. You should only use it when nothing else will work.

There will be places where they might have the same effect IF you got the code right. If you eventually make changes and introduce a mistake and the cast is not correct anymore, static_cast<> will probably catch it, but reinterpret_cast<> will certainly not.

In this very particular scenario, that last argument doesn't hold as much: The API is imposing the semantics on you; they are well understood semantics; and you are casting a (void *).

Still, I would use static_cast<>, and leave reinterpret_cast<> for places where truly extraordinary circumstances force me to bypass the type safety. This is a "normal" cast that is required because of the C-compatible nature of the API.

(see also my post here for more details on the differences between static_cast<> and reinterpret_cast<>)

Answer 7

Everybody has noted that reinterpret_cast<> is more dangerous than static_cast<>.
This is because reinterpret_cast<> ignores all type information and just assigns a new type without any real processing, as a result the processing done is implementation defined (though usually the bit patterns of the pointers are the same).

The thing everybody fails to mention is that reinterpret_cast<> is a means to document your program. It tells somebody reading the code that we had to compromise something and as a result we have ended up with a dangerous cast, and be careful when you mess with this code.

Use the reinterpret_cast<> to highlight these dangerous areas in the code.

When casting from a void* there is not type information for the cast to work with.
So you are either doing an invalid cast or a casting back to the original type that was previously cast into a void*. Any other type of casting is going to end up with some undefined behavior.

This is the perfect situation to use reinterpret_cast<> as the standard guarantees that casting a pointer to void* and back to its original type using reinterpret_cast<> will work. And by using reinterpret_cast<> you are pointing out to the humans that come along afterwords that something bad is happening here.

Answer 8

You should really do whatever the win32 documentation says is the right thing to do. That's what's most likely to work and most likely to be forward compatible, unless it's author is utterly clueless I suppose.

Update: I've looked it up. The Win32 documentation uses C style casts. In this case, C++ defines a C style cast to perform a static cast. So the correct answer is: use static_cast. Or a C style cast, but they're generally best avoided.