Introduction
Most programmers learn C before C++, and get used to C style casting. When writing C++, sometimes we may be confused about when to use static_cast<>
and when to use reinterpret_cast<>
. In this article, I will illustrate what static_cast<>
actually does, and will show some cases that will lead to errors.
Generic Types
float f = 12.3;
float* pf = &f;
int n = static_cast<int>(f);
void* pv = static_cast<void*>(pf);
int* pn2 = static_cast<int*>(pv);
int* pi = reinterpret_cast<int*>(pf);
In short, static_cast<>
will try to convert, e.g., float-to-integer, while reinterpret_cast<>
simply changes the compiler's mind to reconsider that object as another type.
Pointer Types
Pointer casting is a bit complicated, we will use the following classes for the rest of the the article:
class CBaseX
{
public:
int x;
CBaseX() { x = 10; }
void foo() { printf("CBaseX::foo() x=%d\n", x); }
};
class CBaseY
{
public:
int y;
int* py;
CBaseY() { y = 20; py = &y; }
void bar() { printf("CBaseY::bar() y=%d, *py=%d\n", y, *py); }
};
class CDerived : public CBaseX, public CBaseY
{
public:
int z;
};
Case 1: Casting between unrelated classes
CBaseX* pX = new CBaseX();
CBaseY* pY2 = reinterpret_cast<CBaseY*>(pX);
As we learnt in the generic types example, static_cast<>
will fail if you try to cast an object to another unrelated class, while reinterpret_cast<>
will always succeed by "cheating" the compiler to believe that the object is really that unrelated class.
Case 2: Casting to related classes
1. CDerived* pD = new CDerived();
2. printf("CDerived* pD = %x\n", (int)pD);
3.
4.
5. CBaseY* pY1 = pD;
6. printf("CBaseY* pY1 = %x\n", (int)pY1);
7. CDerived* pD1 = static_cast<CDerived*>(pY1);
8. printf("CDerived* pD1 = %x\n", (int)pD1);
9.
10.
11. CBaseY* pY2 = reinterpret_cast<CBaseY*>(pD);
12. printf("CBaseY* pY2 = %x\n", (int)pY2);
13.
14.
15. CBaseY* pY3 = new CBaseY();
16. printf("CBaseY* pY3 = %x\n", (int)pY3);
17. CDerived* pD3 = static_cast<CDerived*>(pY3);
18. printf("CDerived* pD3 = %x\n", (int)pD3);
---------------------- output ---------------------------
CDerived* pD = 392fb8
CBaseY* pY1 = 392fbc
CDerived* pD1 = 392fb8
CBaseY* pY2 = 392fb8
CBaseY* pY3 = 390ff0
CDerived* pD3 = 390fec
Noted that when static_cast<>
-ing CDerived*
to CBaseY*
(line 5), the result is CDerived*
offset by 4. To know what static_cast<>
is actually doing, we have to take a look at the memory layout of CDerived
.
Memory Layout of CDerived

As shown in the diagram, CDerived
's memory layout contains two objects, CBaseX
and CBaseY
, and the compiler knows this. Therefore, when you cast CDerived*
to CBaseY*
, it adds the pointer by 4, and when you cast CBaseY
to CDerived
, it subtracts the pointer by 4. However, you can do this even if it is not a CDerived
(line 14-18) [1].
Of course, the problem happens only if you have multiple inheritance. static_cast<>
and reinterpret_cast<>
make no different if you are casting CDerived
to CBaseX
.
Case 3: Casting back and forth between void*
Because any pointer can be cast to void*
, and void*
can be cast back to any pointer (true for both static_cast<>
and reinterpret_cast<>
), errors may occur if not handled carefully.
CDerived* pD = new CDerived();
printf("CDerived* pD = %x\n", (int)pD);
CBaseY* pY = pD;
printf("CBaseY* pY = %x\n", (int)pY);
void* pV1 = pY;
printf("void* pV1 = %x\n", (int)pV1);
CDerived* pD2 = static_cast<CDerived*>(pV1);
printf("CDerived* pD2 = %x\n", (int)pD2);
---------------------- output ---------------------------
CDerived* pD = 392fb8
CBaseY* pY = 392fbc
void* pV1 = 392fbc
CDerived* pD2 = 392fbc
Once we have cast the pointer to void*
, we can't cast it back to the original class easily. In the above example, the only way to get back a CDerived*
from a void*
is to cast it to a CBaseY*
and then to CDerived*
. But if we are not sure whether it is CBaseY*
or CDerived*
, then we have to use dynamic_cast<>
or typeid
[2].
Footnote
dynamic_cast<>
, on the other hand, can guard against casting a generic CBaseY*
to CDerived*
.
dynamic_cast<>
requires the classes to be "polymorphic", i.e., contains "virtual" function, and hence can't be void*
.
References
History
- 3 Feb 2006: Initial version uploaded.