C++ When should we prefer to use a two chained static_cast over reinterpret_cast

by

reinterpret_cast should be a huge flashing symbol that says THIS LOOKS CRAZY BUT I KNOW WHAT I’M DOING. Don’t use it just out of laziness.

reinterpret_cast means “treat these bits as …” Chained static casts are not the same because they may modify their targets according to the inheritence lattice.

struct A {
    int x;
};

struct B {
    int y;
};

struct C : A, B {
    int z;
};

C c;
A * a = &c;

int main () {
    assert (reinterpret_cast <B *> (a) != static_cast <B *> (static_cast <C *> (a)));
}

If you are not 100% sure that a points to a b, use dynamic_cast which will search for the above solution (albeit with a runtime cost). Bear in mind that this may return NULL or throw on failure.

I’m trying to think of times when I’ve actually used reinterpret_cast, there are really only two:

  • when a function is zipping/encrypting an arbitrary buffer and I want to use a const char * to traverse it
  • if(*reinterpret_cast<uint32_t*>(array_of_4_bytes_A) < *reinterpret_cast<uint32_t*>(array_of_4_bytes_B) or somesuch. Lines like this invite scrutiny and demand comments.

Otherwise if you have a A* which is really a B* then you probably want a union.

More Related Contents:

  1. Why do we have reinterpret_cast in C++ when two chained static_cast can do its job?
  2. Why use static_cast(x) instead of (int)x?
  3. When to use reinterpret_cast?
  4. Should I use static_cast or reinterpret_cast when casting a void* to whatever
  5. What is the difference between static_cast and C style casting?
  6. casting via void* instead of using reinterpret_cast [duplicate]
  7. Is reinterpret_cast type punning actually undefined behavior?
  8. Why doesn’t this reinterpret_cast compile?
  9. Is casting std::pair const& to std::pair const& safe?
  10. Why can’t I static_cast between char * and unsigned char *?
  11. Should I use a C++ reinterpret_cast over a C-style cast?
  12. Why Doesn’t reinterpret_cast Force copy_n for Casts between Same-Sized Types?
  13. Why it is so ? And It is without you explicitly do casting [duplicate]
  14. When should static_cast, dynamic_cast, const_cast and reinterpret_cast be used?
  15. Implicit type conversion rules in C++ operators
  16. How is a variable at the same address producing 2 different values? [duplicate]
  17. What is the difference between (type)value and type(value)?
  18. Efficient unsigned-to-signed cast avoiding implementation-defined behavior
  19. error: cast from ‘void*’ to ‘int’ loses precision
  20. Implicit conversion from char** to const char**
  21. Weird Behaviour with const_cast [duplicate]
  22. Can a cast operator be explicit?
  23. Difference in behavior while using dynamic_cast with reference and pointers
  24. Casting int to bool in C/C++
  25. What is the difference between C-like casting and functional casting? [duplicate]
  26. Why can’t static_cast be used to down-cast when virtual inheritance is involved?
  27. C++ class member function pointer to function pointer
  28. Performance hit from C++ style casts?
  29. Handling overflow when casting doubles to integers in C
  30. C++: Why is const_cast evil?

Leave a Comment