reinterpret_cast
This is the least safe of the casting
mechanisms, and the one most likely to produce bugs. A reinterpret_cast
pretends that an object is just a bit pattern that can be treated (for some dark
purpose) as if it were an entirely different type of object. This is the
low-level bit twiddling that C is notorious for. You’ll virtually always
need to reinterpret_cast back to the original type (or otherwise treat
the variable as its original type) before doing anything else with
it.
//: C03:reinterpret_cast.cpp
#include <iostream>
using namespace std;
const int sz = 100;
struct X { int a[sz]; };
void print(X* x) {
for(int i = 0; i < sz; i++)
cout << x->a[i] << ' ';
cout << endl << "--------------------" << endl;
}
int main() {
X x;
print(&x);
int* xp = reinterpret_cast<int*>(&x);
for(int* i = xp; i < xp + sz; i++)
*i = 0;
// Can't use xp as an X* at this point
// unless you cast it back:
print(reinterpret_cast<X*>(xp));
// In this example, you can also just use
// the original identifier:
print(&x);
} ///:~
In this simple example, struct X
just contains an array of int, but when you create one on the stack as in
X x, the values of each of the ints are garbage (this is shown
using the print( ) function to display the contents of the
struct). To initialize them, the address of the X is taken and
cast to an int pointer, which is then walked through the array to set
each int to zero. Notice how the upper bound for i is calculated
by “adding” sz to xp; the compiler knows that you
actually want sz pointer locations greater than xp and it does the
correct pointer arithmetic for you.
The idea of reinterpret_cast is
that when you use it, what you get is so foreign that it cannot be used for the
type’s original purpose unless you cast it back. Here, we see the cast
back to an X* in the call to print, but of course since you still have
the original identifier you can also use that. But the xp is only useful
as an int*, which is truly a “reinterpretation” of the
original X.
A reinterpret_cast often indicates
inadvisable and/or nonportable programming, but it’s available when you
decide you have to use
it.
