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
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; … Read more
They are completely different types see standard: 3.9.1 Fundamental types [basic.fundamental] 1 Objects declared as characters char) shall be large enough to store any member of the implementation’s basic character set. If a character from this set is stored in a character object, the integral value of that character object is equal to the value … Read more
static_cast<T>(e) is equivalent to creating an invented temporary variable v in the following way: T v(e); //where T is an arbitrary type and e is an arbitrary expression. The runtime cost of a static_cast is exactly the cost of the above statement
[*] 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
No, it’s not guaranteed. The only thing prohibiting any compiler from inserting padding between x and y, or between y and z is common sense. There is no rule in any language standard that would disallow it. Even if there is no padding, even if the representation of A is exactly the same as that … 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
Just do char* only_valid_data = new char[data_size]; to allocate. To free you do delete[] only_valid_data; Important note: When you allocate memory with new it will allocate data_size elements, not data_size bytes (like malloc does). The size of an element is the size of the non-pointer base type, in your case e.g. sizeof(*only_valid_data). In this case … Read more