You might want to overload operator ++ for your enum if you really want to iterate its values: Foo& operator++( Foo& f ) { using UT = std::underlying_type< Foo >::type; f = static_cast< Foo >( static_cast< UT >( f ) + 1 ); return f; } and use for (Foo foo = Foo::First; foo <= … Read more
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
why doesn’t reinterpret_cast handle that for me? One reason is that the size, alignment, and bit representations aren’t specified, so such a conversion wouldn’t be portable. However, that wouldn’t really justify making the behaviour undefined, just implementation-defined. By making it undefined, the compiler is allowed to assume that expressions of unrelated types don’t access the … 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
I think C/C++ are lacking a generic function pointer type, like void* as a generic object pointer type. Generally, converting from one function pointer into another is supported, provided that you don’t call the wrong function pointer type. See [expr.reinterpret.cast]/6: A function pointer can be explicitly converted to a function pointer of a different type. … Read more
The problem with C-Style casts is that they do a lot under the hood. See here for a detailed explanation: http://anteru.net/2007/12/18/200/ You should try to always use the C++-casts, makes life easier in the long run. The main problem with C-style casts in this case is that you could have written (char*)(&v) while with reinterpret_cast, … Read more
At runtime the C++ language has the concept of Undefined Behavior. Under certain (well specified) conditions, the program has Undefined Behavior, that means that it can exhibit any behavior: it can crash, it can hang forever, it can print gibberish, it can appear to work, or it can do anything. A simplified explanation of why … Read more
The behaviour of the cast comes down to [expr.static.cast]/13; A prvalue of type “pointer to cv1 void” can be converted to a prvalue of type “pointer to cv2 T”, where T is an object type and cv2 is the same cv-qualification as, or greater cv-qualification than, cv1. If the original pointer value represents the address … 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
Yes, because both classes here are standard-layout types, you can convert between &b and &b.a. reinterpret_cast<A*>(p) is defined to be the same as static_cast<A*>(static_cast<void*>(p)), (5.2.10p7) so both your questions are equivalent. For standard-layout classes, the address of the struct/class is the same as the address of its first non-static member (9.2p19). And static_cast to/from void* … Read more