There are things that reinterpret_cast can do that no sequence of static_casts can do (all from C++03 5.2.10): A pointer can be explicitly converted to any integral type large enough to hold it. A value of integral type or enumeration type can be explicitly converted to a pointer. A pointer to a function can be … Read more
[*] The technical problem is that there’s no way to work out from a Base* what the offset is between the start of the Base sub-object and the start of the Derived object. In your example it appears OK, because there’s only one class in sight with a Base base, and so it appears irrelevant … Read more
C++ style casts are checked by the compiler. C style casts aren’t and can fail at runtime. Also, c++ style casts can be searched for easily, whereas it’s really hard to search for c style casts. Another big benefit is that the 4 different C++ style casts express the intent of the programmer more clearly. … Read more
Use static_cast: it is the narrowest cast that exactly describes what conversion is made here. There’s a misconception that using reinterpret_cast would be a better match because it means “completely ignore type safety and just cast from A to B”. However, this doesn’t actually describe the effect of a reinterpret_cast. Rather, reinterpret_cast has a number of … Read more
The main reason is that classic C casts make no distinction between what we call static_cast<>(), reinterpret_cast<>(), const_cast<>(), and dynamic_cast<>(). These four things are completely different. A static_cast<>() is usually safe. There is a valid conversion in the language, or an appropriate constructor that makes it possible. The only time it’s a bit risky is … Read more