When should static cast dynamic cast const cast and reinterpret cast be used

Question

What are the proper uses of    static cast dynamic cast const cast reinterpret cast C-style cast  type value Function-style cast type value    How does one decide which to use in which specific cases

User · Answer

To understand  let s consider below code snippet   struct Foo    struct Bar     int main int argc  char   argv        Foo  f   new Foo       Bar  b1   f                                   1      Bar  b2   static cast lt Bar  gt  f                 2      Bar  b3   dynamic cast lt Bar  gt  f                3      Bar  b4   reinterpret cast lt Bar  gt  f            4      Bar  b5   const cast lt Bar  gt  f                  5       return 0      Only line  4  compiles without error  Only reinterpret cast can be used to convert a pointer to an object to a pointer to an any unrelated object type   One this to be noted is  The dynamic cast would fail at run-time  however on most compilers it will also fail to compile because there are no virtual functions in the struct of the pointer being casted  meaning dynamic cast will work with only polymorphic class pointers   When to use C   cast    Use static cast as the equivalent of a C-style cast that does value conversion  or when we need to explicitly up-cast a pointer from a class to its superclass  Use const cast to remove the const qualifier    Use reinterpret cast to do unsafe conversions of pointer types to and from integer and other pointer types  Use this only if we know what we are doing and we understand the aliasing issues

User · Answer

Use dynamic cast for converting pointers references within an inheritance hierarchy   Use static cast for ordinary type conversions   Use reinterpret cast for low-level reinterpreting of bit patterns   Use with extreme caution   Use const cast for casting away const volatile   Avoid this unless you are stuck using a const-incorrect API

User · Answer

Does this answer your question   I have never used reinterpret cast  and wonder whether running into a case that needs it isn t a smell of bad design  In the code base I work on dynamic cast is used a lot  The difference with  static cast is that a dynamic cast does runtime checking which may  safer  or may not  more overhead  be what you want  see msdn

User · Answer

Use dynamic cast for converting pointers references within an inheritance hierarchy   Use static cast for ordinary type conversions   Use reinterpret cast for low-level reinterpreting of bit patterns   Use with extreme caution   Use const cast for casting away const volatile   Avoid this unless you are stuck using a const-incorrect API

User · Answer

static cast vs dynamic cast vs reinterpret cast internals view on a downcast upcast  In this answer  I want to compare these three mechanisms on a concrete upcast downcast example and analyze what happens to the underlying pointers memory assembly to give a concrete understanding of how they compare   I believe that this will give a good intuition on how those casts are different    static cast  does one address offset at runtime  low runtime impact  and no safety checks that a downcast is correct  dyanamic cast  does the same address offset at runtime like static cast  but also and an expensive safety check that a downcast is correct using RTTI   This safety check allows you to query if a base class pointer is of a given type at runtime by checking a return of nullptr which indicates an invalid downcast   Therefore  if your code is not able to check for that nullptr and take a valid non-abort action  you should just use static cast instead of dynamic cast   If an abort is the only action your code can take  maybe you only want to enable the dynamic cast in debug builds  -NDEBUG   and use static cast otherwise  e g  as done here  to not slow down your fast runs  reinterpret cast  does nothing at runtime  not even the address offset  The pointer must point exactly to the correct type  not even a base class works  You generally don t want this unless raw byte streams are involved    Consider the following code example   main cpp   include  lt iostream gt   struct B1       B1 int int in b1    int in b1 int in b1         virtual  B1          void f0          virtual int f1     return 1        int int in b1      struct B2       B2 int int in b2    int in b2 int in b2         virtual  B2          virtual int f2     return 2        int int in b2      struct D   public B1  public B2       D int int in b1  int int in b2  int int in d            B1 int in b1   B2 int in b2   int in d int in d         void d          int f2     return 3        int int in d      int main         B2  b2s 2       B2 b2 11       D  dp      D d 1  2  3           The memory layout must support the virtual method call use case      b2s 0     amp b2         An upcast is an implicit static cast lt  gt         b2s 1     amp d      std  cout  lt  lt    amp d              lt  lt   amp d            lt  lt  std  endl      std  cout  lt  lt   b2s 0           lt  lt  b2s 0         lt  lt  std  endl      std  cout  lt  lt   b2s 1           lt  lt  b2s 1         lt  lt  std  endl      std  cout  lt  lt   b2s 0 - gt f2      lt  lt  b2s 0 - gt f2    lt  lt  std  endl      std  cout  lt  lt   b2s 1 - gt f2      lt  lt  b2s 1 - gt f2    lt  lt  std  endl          Now for some downcasts          Cannot be done implicitly        error  invalid conversion from    B2     to    D      -fpermissive         dp    b2s 0            Undefined behaviour to an unrelated memory address because this is a B2  not D      dp   static cast lt D  gt  b2s 0        std  cout  lt  lt   static cast lt D  gt  b2s 0                 lt  lt  dp            lt  lt  std  endl      std  cout  lt  lt   static cast lt D  gt  b2s 0  - gt int in d     lt  lt  dp- gt int in d  lt  lt  std  endl          OK     dp   static cast lt D  gt  b2s 1        std  cout  lt  lt   static cast lt D  gt  b2s 1                 lt  lt  dp            lt  lt  std  endl      std  cout  lt  lt   static cast lt D  gt  b2s 1  - gt int in d     lt  lt  dp- gt int in d  lt  lt  std  endl          Segfault because dp is nullptr      dp   dynamic cast lt D  gt  b2s 0        std  cout  lt  lt   dynamic cast lt D  gt  b2s 0                lt  lt  dp            lt  lt  std  endl        std  cout  lt  lt   dynamic cast lt D  gt  b2s 0  - gt int in d    lt  lt  dp- gt int in d  lt  lt  std  endl          OK     dp   dynamic cast lt D  gt  b2s 1        std  cout  lt  lt   dynamic cast lt D  gt  b2s 1                lt  lt  dp            lt  lt  std  endl      std  cout  lt  lt   dynamic cast lt D  gt  b2s 1  - gt int in d    lt  lt  dp- gt int in d  lt  lt  std  endl          Undefined behaviour to an unrelated memory address because this        did not calculate the offset to get from B2  to D       dp   reinterpret cast lt D  gt  b2s 1        std  cout  lt  lt   reinterpret cast lt D  gt  b2s 1                lt  lt  dp            lt  lt  std  endl      std  cout  lt  lt   reinterpret cast lt D  gt  b2s 1  - gt int in d    lt  lt  dp- gt int in d  lt  lt  std  endl       Compile  run and disassemble with   g   -ggdb3 -O0 -std c  11 -Wall -Wextra -pedantic -o main out main cpp setarch  uname -m  -R   main out gdb -batch -ex  disassemble rs main  main out   where setarch is used to disable ASLR to make it easier to compare runs   Possible output    amp d           0x7fffffffc930 b2s 0        0x7fffffffc920 b2s 1        0x7fffffffc940 b2s 0 - gt f2   2 b2s 1 - gt f2   3 static cast lt D  gt  b2s 0              0x7fffffffc910 static cast lt D  gt  b2s 0  - gt int in d  1 static cast lt D  gt  b2s 1              0x7fffffffc930 static cast lt D  gt  b2s 1  - gt int in d  3 dynamic cast lt D  gt  b2s 0             0 dynamic cast lt D  gt  b2s 1             0x7fffffffc930 dynamic cast lt D  gt  b2s 1  - gt int in d 3 reinterpret cast lt D  gt  b2s 1             0x7fffffffc940 reinterpret cast lt D  gt  b2s 1  - gt int in d 32767   Now  as mentioned at  https   en wikipedia org wiki Virtual method table in order to support the virtual method calls efficiently  the memory data structure of D has to look something like   B1     0  pointer to virtual method table of B1    4  value of int in b1  B2     0  pointer to virtual method table of B2    4  value of int in b2  D     0  pointer to virtual method table of D  for B1     4  value of int in b1    8  pointer to virtual method table of D  for B2    12  value of int in b2   16  value of int in d   The key fact is that the memory data structure of D contains inside it memory structure compatible with that of B1 and that of B2 internally   Therefore we reach the critical conclusion      an upcast or downcast only needs to shift the pointer value by a value known at compile time   This way  when D gets passed to the base type array  the type cast actually calculates that offset and points something that looks exactly like a valid B2 in memory   b2s 1     amp d    except that this one has the vtable for D instead of B2  and therefore all virtual calls work transparently   Now  we can finally get back to type casting and the analysis of our concrete example   From the stdout output we see    amp d           0x7fffffffc930 b2s 1        0x7fffffffc940   Therefore  the implicit static cast done there did correctly calculate the offset from the full D data structure at 0x7fffffffc930 to the B2 like one which is at 0x7fffffffc940  We also infer that what lies between 0x7fffffffc930 and 0x7fffffffc940 is likely be the B1 data and vtable   Then  on the downcast sections  it is now easy to understand how the invalid ones fail and why    static cast lt D  gt  b2s 0              0x7fffffffc910  the compiler just went up 0x10 at compile time bytes to try and go from a B2 to the containing D  But because b2s 0  was not a D  it now points to an undefined memory region   The disassembly is   49          dp   static cast lt D  gt  b2s 0       0x0000000000000fc8  lt  414 gt     48 8b 45 d0     mov    -0x30  rbp   rax    0x0000000000000fcc  lt  418 gt     48 85 c0        test    rax  rax    0x0000000000000fcf  lt  421 gt     74 0a   je     0xfdb  lt main   433 gt     0x0000000000000fd1  lt  423 gt     48 8b 45 d0     mov    -0x30  rbp   rax    0x0000000000000fd5  lt  427 gt     48 83 e8 10     sub     0x10  rax    0x0000000000000fd9  lt  431 gt     eb 05   jmp    0xfe0  lt main   438 gt     0x0000000000000fdb  lt  433 gt     b8 00 00 00 00  mov     0x0  eax    0x0000000000000fe0  lt  438 gt     48 89 45 98     mov     rax -0x68  rbp    so we see that GCC does    check if pointer is NULL  and if yes return NULL otherwise  subtract 0x10 from it to reach the D which does not exist  dynamic cast lt D  gt  b2s 0             0  C   actually found that the cast was invalid and returned nullptr   There is no way this can be done at compile time  and we will confirm that from the disassembly   59          dp   dynamic cast lt D  gt  b2s 0       0x00000000000010ec  lt  706 gt     48 8b 45 d0     mov    -0x30  rbp   rax    0x00000000000010f0  lt  710 gt     48 85 c0        test    rax  rax    0x00000000000010f3  lt  713 gt     74 1d   je     0x1112  lt main   744 gt     0x00000000000010f5  lt  715 gt     b9 10 00 00 00  mov     0x10  ecx    0x00000000000010fa  lt  720 gt     48 8d 15 f7 0b 20 00    lea    0x200bf7  rip   rdx          0x201cf8  lt  ZTI1D gt     0x0000000000001101  lt  727 gt     48 8d 35 28 0c 20 00    lea    0x200c28  rip   rsi          0x201d30  lt  ZTI2B2 gt     0x0000000000001108  lt  734 gt     48 89 c7        mov     rax  rdi    0x000000000000110b  lt  737 gt     e8 c0 fb ff ff  callq  0xcd0  lt   dynamic cast plt gt     0x0000000000001110  lt  742 gt     eb 05   jmp    0x1117  lt main   749 gt     0x0000000000001112  lt  744 gt     b8 00 00 00 00  mov     0x0  eax    0x0000000000001117  lt  749 gt     48 89 45 98     mov     rax -0x68  rbp    First there is a NULL check  and it returns NULL if th einput is NULL   Otherwise  it sets up some arguments in the RDX  RSI and RDI and calls   dynamic cast   I don t have the patience to analyze this further now  but as others said  the only way for this to work is for   dynamic cast to access some extra RTTI in-memory data structures that represent the class hierarchy   It must therefore start from the B2 entry for that table  then walk this class hierarchy until it finds that the vtable for a D typecast from b2s 0    This is why reinterpret cast is potentially expensive  Here is an example where a one liner patch converting a dynamic cast to a static cast in a complex project reduced runtime by 33    reinterpret cast lt D  gt  b2s 1             0x7fffffffc940 this one just believes us blindly  we said there is a D at address b2s 1   and the compiler does no offset calculations   But this is wrong  because D is actually at 0x7fffffffc930  what is at 0x7fffffffc940 is the B2-like structure inside D  So trash gets accessed   We can confirm this from the horrendous -O0 assembly that just moves the value around   70          dp   reinterpret cast lt D  gt  b2s 1       0x00000000000011fa  lt  976 gt     48 8b 45 d8     mov    -0x28  rbp   rax    0x00000000000011fe  lt  980 gt     48 89 45 98     mov     rax -0x68  rbp     Related questions    When should static cast  dynamic cast  const cast and reinterpret cast be used  How is dynamic cast implemented Downcasting using the   39 static cast  39  in C     Tested on Ubuntu 18 04 amd64  GCC 7 4 0

User · Answer

Does this answer your question   I have never used reinterpret cast  and wonder whether running into a case that needs it isn t a smell of bad design  In the code base I work on dynamic cast is used a lot  The difference with  static cast is that a dynamic cast does runtime checking which may  safer  or may not  more overhead  be what you want  see msdn

User · Answer

In addition to the other answers so far  here is unobvious example where static cast is not sufficient so that reinterpret cast is needed  Suppose there is a function which in an output parameter returns pointers to objects of different classes  which do not share a common base class   A real example of such function is CoCreateInstance    see the last parameter  which is in fact void     Suppose you request particular class of object from this function  so you know in advance the type for the pointer  which you often do for COM objects   In this case you cannot cast pointer to your pointer into void   with static cast  you need reinterpret cast lt void   gt   amp yourPointer     In code    include  lt windows h gt   include  lt netfw h gt        INetFwPolicy2  pNetFwPolicy2   nullptr  HRESULT hr   CoCreateInstance   uuidof NetFwPolicy2   nullptr      CLSCTX INPROC SERVER    uuidof INetFwPolicy2         static cast lt void   gt   amp pNetFwPolicy2  would give a compile error     reinterpret cast lt void   gt   amp pNetFwPolicy2       However  static cast works for simple pointers  not pointers to pointers   so the above code can be rewritten to avoid reinterpret cast  at a price of an extra variable  in the following way    include  lt windows h gt   include  lt netfw h gt        INetFwPolicy2  pNetFwPolicy2   nullptr  void  tmp   nullptr  HRESULT hr   CoCreateInstance   uuidof NetFwPolicy2   nullptr      CLSCTX INPROC SERVER    uuidof INetFwPolicy2        amp tmp    pNetFwPolicy2   static cast lt INetFwPolicy2  gt  tmp

User · Answer

While other answers nicely described all differences between C   casts  I would like to add a short note why you should not use C-style casts  Type  var and Type var    For C   beginners C-style casts look like being the superset operation over C   casts  static cast lt      dynamic cast lt      const cast lt      reinterpret cast lt      and someone could prefer them over the C   casts  In fact C-style cast is the superset and shorter to write   The main problem of C-style casts is that they hide developer real intention of the cast  The C-style casts can do virtually all types of casting from normally safe casts done by static cast lt     and dynamic cast lt     to potentially dangerous casts like const cast lt      where const modifier can be removed so the const variables can be modified and reinterpret cast lt     that can even reinterpret integer values to pointers   Here is the sample   int a rand       Random number   int  pa1 reinterpret cast lt int  gt  a      OK  Here developer clearly expressed he wanted to do this potentially dangerous operation   int  pa2 static cast lt int  gt  a      Compiler error  int  pa3 dynamic cast lt int  gt  a      Compiler error   int  pa4  int   a     OK  C-style cast can do such cast  The question is if it was intentional or developer just did some typo    pa4 5     Program crashes    The main reason why C   casts were added to the language was to allow a developer to clarify his intentions - why he is going to do that cast  By using C-style casts which are perfectly valid in C   you are making your code less readable and more error prone especially for other developers who didn t create your code  So to make your code more readable and explicit you should always prefer C   casts over C-style casts   Here is a short quote from Bjarne Stroustrup s  the author of C    book The C   Programming Language 4th edition - page 302      This C-style cast is far more dangerous than the named conversion operators   because the notation is harder to spot in a large program and the kind of conversion intended by the programmer is not explicit

User · Answer

It might help if you know little bit of internals    static cast  C   compiler already knows how to convert between scaler types such as float to int  Use static cast for them  When you ask compiler to convert from type A to B  static cast calls B s constructor passing A as param  Alternatively  A could have a conversion operator  i e  A  operator B      If B doesn t have such constructor  or A doesn t have a conversion operator  then you get compile time error  Cast from A  to B  always succeeds if A and B are in inheritance hierarchy  or void  otherwise you get compile error  Gotcha  If you cast base pointer to derived pointer but if actual object is not really derived type then you don t get error  You get bad pointer and  very likely a segfault at runtime  Same goes for A amp  to B amp   Gotcha  Cast from Derived to Base or viceversa creates new copy  For people coming from C  Java  this can be a huge surprise because the result is basically a chopped off object created from Derived   dynamic cast  dynamic cast uses runtime type information to figure out if cast is valid  For example   Base   to  Derived   may fail if pointer is not actually of derived type  This means  dynamic cast is very expensive compared to static cast  For A  to B   if cast is invalid then dynamic cast will return nullptr  For A amp  to B amp  if cast is invalid then dynamic cast will throw bad cast exception  Unlike other casts  there is runtime overhead   const cast  While static cast can do non-const to const it can t go other way around  The const cast can do both ways  One example where this comes handy is iterating through some container like set lt T gt  which only returns its elements as const to make sure you don t change its key  However if your intent is to modify object s non-key members then it should be ok  You can use const cast to remove constness  Another example is when you want to implement T amp  SomeClass  foo   as well as const T amp  SomeClass  foo   const  To avoid code duplication  you can apply const cast to return value of one function from another   reinterpret cast  This basically says that take these bytes at this memory location and think of it as given object  For example  you can load 4 bytes of float to 4 bytes of int to see how bits in float looks like  Obviously  if data is not correct for the type  you may get segfault  There is no runtime overhead for this cast

User · Answer

It might help if you know little bit of internals    static cast  C   compiler already knows how to convert between scaler types such as float to int  Use static cast for them  When you ask compiler to convert from type A to B  static cast calls B s constructor passing A as param  Alternatively  A could have a conversion operator  i e  A  operator B      If B doesn t have such constructor  or A doesn t have a conversion operator  then you get compile time error  Cast from A  to B  always succeeds if A and B are in inheritance hierarchy  or void  otherwise you get compile error  Gotcha  If you cast base pointer to derived pointer but if actual object is not really derived type then you don t get error  You get bad pointer and  very likely a segfault at runtime  Same goes for A amp  to B amp   Gotcha  Cast from Derived to Base or viceversa creates new copy  For people coming from C  Java  this can be a huge surprise because the result is basically a chopped off object created from Derived   dynamic cast  dynamic cast uses runtime type information to figure out if cast is valid  For example   Base   to  Derived   may fail if pointer is not actually of derived type  This means  dynamic cast is very expensive compared to static cast  For A  to B   if cast is invalid then dynamic cast will return nullptr  For A amp  to B amp  if cast is invalid then dynamic cast will throw bad cast exception  Unlike other casts  there is runtime overhead   const cast  While static cast can do non-const to const it can t go other way around  The const cast can do both ways  One example where this comes handy is iterating through some container like set lt T gt  which only returns its elements as const to make sure you don t change its key  However if your intent is to modify object s non-key members then it should be ok  You can use const cast to remove constness  Another example is when you want to implement T amp  SomeClass  foo   as well as const T amp  SomeClass  foo   const  To avoid code duplication  you can apply const cast to return value of one function from another   reinterpret cast  This basically says that take these bytes at this memory location and think of it as given object  For example  you can load 4 bytes of float to 4 bytes of int to see how bits in float looks like  Obviously  if data is not correct for the type  you may get segfault  There is no runtime overhead for this cast

User · Answer

Does this answer your question   I have never used reinterpret cast  and wonder whether running into a case that needs it isn t a smell of bad design  In the code base I work on dynamic cast is used a lot  The difference with  static cast is that a dynamic cast does runtime checking which may  safer  or may not  more overhead  be what you want  see msdn

User · Answer

static cast is the first cast you should attempt to use  It does things like implicit conversions between types  such as int to float  or pointer to void    and it can also call explicit conversion functions  or implicit ones   In many cases  explicitly stating static cast isn t necessary  but it s important to note that the T something  syntax is equivalent to  T something and should be avoided  more on that later   A T something  something else  is safe  however  and guaranteed to call the constructor   static cast can also cast through inheritance hierarchies  It is unnecessary when casting upwards  towards a base class   but when casting downwards it can be used as long as it doesn t cast through virtual inheritance  It does not do checking  however  and it is undefined behavior to static cast down a hierarchy to a type that isn t actually the type of the object     const cast can be used to remove or add const to a variable  no other C   cast is capable of removing it  not even reinterpret cast   It is important to note that modifying a formerly const value is only undefined if the original variable is const  if you use it to take the const off a reference to something that wasn t declared with const  it is safe  This can be useful when overloading member functions based on const  for instance  It can also be used to add const to an object  such as to call a member function overload   const cast also works similarly on volatile  though that s less common     dynamic cast is exclusively used for handling polymorphism  You can cast a pointer or reference to any polymorphic type to any other class type  a polymorphic type has at least one virtual function  declared or inherited   You can use it for more than just casting downwards     you can cast sideways or even up another chain  The dynamic cast will seek out the desired object and return it if possible  If it can t  it will return nullptr in the case of a pointer  or throw std  bad cast in the case of a reference   dynamic cast has some limitations  though  It doesn t work if there are multiple objects of the same type in the inheritance hierarchy  the so-called  dreaded diamond   and you aren t using virtual inheritance  It also can only go through public inheritance - it will always fail to travel through protected or private inheritance  This is rarely an issue  however  as such forms of inheritance are rare     reinterpret cast is the most dangerous cast  and should be used very sparingly  It turns one type directly into another     such as casting the value from one pointer to another  or storing a pointer in an int  or all sorts of other nasty things  Largely  the only guarantee you get with reinterpret cast is that normally if you cast the result back to the original type  you will get the exact same value  but not if the intermediate type is smaller than the original type   There are a number of conversions that reinterpret cast cannot do  too  It s used primarily for particularly weird conversions and bit manipulations  like turning a raw data stream into actual data  or storing data in the low bits of a pointer to aligned data     C-style cast and function-style cast are casts using  type object or type object   respectively  and are functionally equivalent  They are defined as the first of the following which succeeds    const cast static cast  though ignoring access restrictions  static cast  see above   then const cast reinterpret cast reinterpret cast  then const cast   It can therefore be used as a replacement for other casts in some instances  but can be extremely dangerous because of the ability to devolve into a reinterpret cast  and the latter should be preferred when explicit casting is needed  unless you are sure static cast will succeed or reinterpret cast will fail  Even then  consider the longer  more explicit option   C-style casts also ignore access control when performing a static cast  which means that they have the ability to perform an operation that no other cast can  This is mostly a kludge  though  and in my mind is just another reason to avoid C-style casts

User · Answer

In addition to the other answers so far  here is unobvious example where static cast is not sufficient so that reinterpret cast is needed  Suppose there is a function which in an output parameter returns pointers to objects of different classes  which do not share a common base class   A real example of such function is CoCreateInstance    see the last parameter  which is in fact void     Suppose you request particular class of object from this function  so you know in advance the type for the pointer  which you often do for COM objects   In this case you cannot cast pointer to your pointer into void   with static cast  you need reinterpret cast lt void   gt   amp yourPointer     In code    include  lt windows h gt   include  lt netfw h gt        INetFwPolicy2  pNetFwPolicy2   nullptr  HRESULT hr   CoCreateInstance   uuidof NetFwPolicy2   nullptr      CLSCTX INPROC SERVER    uuidof INetFwPolicy2         static cast lt void   gt   amp pNetFwPolicy2  would give a compile error     reinterpret cast lt void   gt   amp pNetFwPolicy2       However  static cast works for simple pointers  not pointers to pointers   so the above code can be rewritten to avoid reinterpret cast  at a price of an extra variable  in the following way    include  lt windows h gt   include  lt netfw h gt        INetFwPolicy2  pNetFwPolicy2   nullptr  void  tmp   nullptr  HRESULT hr   CoCreateInstance   uuidof NetFwPolicy2   nullptr      CLSCTX INPROC SERVER    uuidof INetFwPolicy2        amp tmp    pNetFwPolicy2   static cast lt INetFwPolicy2  gt  tmp

User · Answer

static cast vs dynamic cast vs reinterpret cast internals view on a downcast upcast  In this answer  I want to compare these three mechanisms on a concrete upcast downcast example and analyze what happens to the underlying pointers memory assembly to give a concrete understanding of how they compare   I believe that this will give a good intuition on how those casts are different    static cast  does one address offset at runtime  low runtime impact  and no safety checks that a downcast is correct  dyanamic cast  does the same address offset at runtime like static cast  but also and an expensive safety check that a downcast is correct using RTTI   This safety check allows you to query if a base class pointer is of a given type at runtime by checking a return of nullptr which indicates an invalid downcast   Therefore  if your code is not able to check for that nullptr and take a valid non-abort action  you should just use static cast instead of dynamic cast   If an abort is the only action your code can take  maybe you only want to enable the dynamic cast in debug builds  -NDEBUG   and use static cast otherwise  e g  as done here  to not slow down your fast runs  reinterpret cast  does nothing at runtime  not even the address offset  The pointer must point exactly to the correct type  not even a base class works  You generally don t want this unless raw byte streams are involved    Consider the following code example   main cpp   include  lt iostream gt   struct B1       B1 int int in b1    int in b1 int in b1         virtual  B1          void f0          virtual int f1     return 1        int int in b1      struct B2       B2 int int in b2    int in b2 int in b2         virtual  B2          virtual int f2     return 2        int int in b2      struct D   public B1  public B2       D int int in b1  int int in b2  int int in d            B1 int in b1   B2 int in b2   int in d int in d         void d          int f2     return 3        int int in d      int main         B2  b2s 2       B2 b2 11       D  dp      D d 1  2  3           The memory layout must support the virtual method call use case      b2s 0     amp b2         An upcast is an implicit static cast lt  gt         b2s 1     amp d      std  cout  lt  lt    amp d              lt  lt   amp d            lt  lt  std  endl      std  cout  lt  lt   b2s 0           lt  lt  b2s 0         lt  lt  std  endl      std  cout  lt  lt   b2s 1           lt  lt  b2s 1         lt  lt  std  endl      std  cout  lt  lt   b2s 0 - gt f2      lt  lt  b2s 0 - gt f2    lt  lt  std  endl      std  cout  lt  lt   b2s 1 - gt f2      lt  lt  b2s 1 - gt f2    lt  lt  std  endl          Now for some downcasts          Cannot be done implicitly        error  invalid conversion from    B2     to    D      -fpermissive         dp    b2s 0            Undefined behaviour to an unrelated memory address because this is a B2  not D      dp   static cast lt D  gt  b2s 0        std  cout  lt  lt   static cast lt D  gt  b2s 0                 lt  lt  dp            lt  lt  std  endl      std  cout  lt  lt   static cast lt D  gt  b2s 0  - gt int in d     lt  lt  dp- gt int in d  lt  lt  std  endl          OK     dp   static cast lt D  gt  b2s 1        std  cout  lt  lt   static cast lt D  gt  b2s 1                 lt  lt  dp            lt  lt  std  endl      std  cout  lt  lt   static cast lt D  gt  b2s 1  - gt int in d     lt  lt  dp- gt int in d  lt  lt  std  endl          Segfault because dp is nullptr      dp   dynamic cast lt D  gt  b2s 0        std  cout  lt  lt   dynamic cast lt D  gt  b2s 0                lt  lt  dp            lt  lt  std  endl        std  cout  lt  lt   dynamic cast lt D  gt  b2s 0  - gt int in d    lt  lt  dp- gt int in d  lt  lt  std  endl          OK     dp   dynamic cast lt D  gt  b2s 1        std  cout  lt  lt   dynamic cast lt D  gt  b2s 1                lt  lt  dp            lt  lt  std  endl      std  cout  lt  lt   dynamic cast lt D  gt  b2s 1  - gt int in d    lt  lt  dp- gt int in d  lt  lt  std  endl          Undefined behaviour to an unrelated memory address because this        did not calculate the offset to get from B2  to D       dp   reinterpret cast lt D  gt  b2s 1        std  cout  lt  lt   reinterpret cast lt D  gt  b2s 1                lt  lt  dp            lt  lt  std  endl      std  cout  lt  lt   reinterpret cast lt D  gt  b2s 1  - gt int in d    lt  lt  dp- gt int in d  lt  lt  std  endl       Compile  run and disassemble with   g   -ggdb3 -O0 -std c  11 -Wall -Wextra -pedantic -o main out main cpp setarch  uname -m  -R   main out gdb -batch -ex  disassemble rs main  main out   where setarch is used to disable ASLR to make it easier to compare runs   Possible output    amp d           0x7fffffffc930 b2s 0        0x7fffffffc920 b2s 1        0x7fffffffc940 b2s 0 - gt f2   2 b2s 1 - gt f2   3 static cast lt D  gt  b2s 0              0x7fffffffc910 static cast lt D  gt  b2s 0  - gt int in d  1 static cast lt D  gt  b2s 1              0x7fffffffc930 static cast lt D  gt  b2s 1  - gt int in d  3 dynamic cast lt D  gt  b2s 0             0 dynamic cast lt D  gt  b2s 1             0x7fffffffc930 dynamic cast lt D  gt  b2s 1  - gt int in d 3 reinterpret cast lt D  gt  b2s 1             0x7fffffffc940 reinterpret cast lt D  gt  b2s 1  - gt int in d 32767   Now  as mentioned at  https   en wikipedia org wiki Virtual method table in order to support the virtual method calls efficiently  the memory data structure of D has to look something like   B1     0  pointer to virtual method table of B1    4  value of int in b1  B2     0  pointer to virtual method table of B2    4  value of int in b2  D     0  pointer to virtual method table of D  for B1     4  value of int in b1    8  pointer to virtual method table of D  for B2    12  value of int in b2   16  value of int in d   The key fact is that the memory data structure of D contains inside it memory structure compatible with that of B1 and that of B2 internally   Therefore we reach the critical conclusion      an upcast or downcast only needs to shift the pointer value by a value known at compile time   This way  when D gets passed to the base type array  the type cast actually calculates that offset and points something that looks exactly like a valid B2 in memory   b2s 1     amp d    except that this one has the vtable for D instead of B2  and therefore all virtual calls work transparently   Now  we can finally get back to type casting and the analysis of our concrete example   From the stdout output we see    amp d           0x7fffffffc930 b2s 1        0x7fffffffc940   Therefore  the implicit static cast done there did correctly calculate the offset from the full D data structure at 0x7fffffffc930 to the B2 like one which is at 0x7fffffffc940  We also infer that what lies between 0x7fffffffc930 and 0x7fffffffc940 is likely be the B1 data and vtable   Then  on the downcast sections  it is now easy to understand how the invalid ones fail and why    static cast lt D  gt  b2s 0              0x7fffffffc910  the compiler just went up 0x10 at compile time bytes to try and go from a B2 to the containing D  But because b2s 0  was not a D  it now points to an undefined memory region   The disassembly is   49          dp   static cast lt D  gt  b2s 0       0x0000000000000fc8  lt  414 gt     48 8b 45 d0     mov    -0x30  rbp   rax    0x0000000000000fcc  lt  418 gt     48 85 c0        test    rax  rax    0x0000000000000fcf  lt  421 gt     74 0a   je     0xfdb  lt main   433 gt     0x0000000000000fd1  lt  423 gt     48 8b 45 d0     mov    -0x30  rbp   rax    0x0000000000000fd5  lt  427 gt     48 83 e8 10     sub     0x10  rax    0x0000000000000fd9  lt  431 gt     eb 05   jmp    0xfe0  lt main   438 gt     0x0000000000000fdb  lt  433 gt     b8 00 00 00 00  mov     0x0  eax    0x0000000000000fe0  lt  438 gt     48 89 45 98     mov     rax -0x68  rbp    so we see that GCC does    check if pointer is NULL  and if yes return NULL otherwise  subtract 0x10 from it to reach the D which does not exist  dynamic cast lt D  gt  b2s 0             0  C   actually found that the cast was invalid and returned nullptr   There is no way this can be done at compile time  and we will confirm that from the disassembly   59          dp   dynamic cast lt D  gt  b2s 0       0x00000000000010ec  lt  706 gt     48 8b 45 d0     mov    -0x30  rbp   rax    0x00000000000010f0  lt  710 gt     48 85 c0        test    rax  rax    0x00000000000010f3  lt  713 gt     74 1d   je     0x1112  lt main   744 gt     0x00000000000010f5  lt  715 gt     b9 10 00 00 00  mov     0x10  ecx    0x00000000000010fa  lt  720 gt     48 8d 15 f7 0b 20 00    lea    0x200bf7  rip   rdx          0x201cf8  lt  ZTI1D gt     0x0000000000001101  lt  727 gt     48 8d 35 28 0c 20 00    lea    0x200c28  rip   rsi          0x201d30  lt  ZTI2B2 gt     0x0000000000001108  lt  734 gt     48 89 c7        mov     rax  rdi    0x000000000000110b  lt  737 gt     e8 c0 fb ff ff  callq  0xcd0  lt   dynamic cast plt gt     0x0000000000001110  lt  742 gt     eb 05   jmp    0x1117  lt main   749 gt     0x0000000000001112  lt  744 gt     b8 00 00 00 00  mov     0x0  eax    0x0000000000001117  lt  749 gt     48 89 45 98     mov     rax -0x68  rbp    First there is a NULL check  and it returns NULL if th einput is NULL   Otherwise  it sets up some arguments in the RDX  RSI and RDI and calls   dynamic cast   I don t have the patience to analyze this further now  but as others said  the only way for this to work is for   dynamic cast to access some extra RTTI in-memory data structures that represent the class hierarchy   It must therefore start from the B2 entry for that table  then walk this class hierarchy until it finds that the vtable for a D typecast from b2s 0    This is why reinterpret cast is potentially expensive  Here is an example where a one liner patch converting a dynamic cast to a static cast in a complex project reduced runtime by 33    reinterpret cast lt D  gt  b2s 1             0x7fffffffc940 this one just believes us blindly  we said there is a D at address b2s 1   and the compiler does no offset calculations   But this is wrong  because D is actually at 0x7fffffffc930  what is at 0x7fffffffc940 is the B2-like structure inside D  So trash gets accessed   We can confirm this from the horrendous -O0 assembly that just moves the value around   70          dp   reinterpret cast lt D  gt  b2s 1       0x00000000000011fa  lt  976 gt     48 8b 45 d8     mov    -0x28  rbp   rax    0x00000000000011fe  lt  980 gt     48 89 45 98     mov     rax -0x68  rbp     Related questions    When should static cast  dynamic cast  const cast and reinterpret cast be used  How is dynamic cast implemented Downcasting using the   39 static cast  39  in C     Tested on Ubuntu 18 04 amd64  GCC 7 4 0

User · Answer

To understand  let s consider below code snippet   struct Foo    struct Bar     int main int argc  char   argv        Foo  f   new Foo       Bar  b1   f                                   1      Bar  b2   static cast lt Bar  gt  f                 2      Bar  b3   dynamic cast lt Bar  gt  f                3      Bar  b4   reinterpret cast lt Bar  gt  f            4      Bar  b5   const cast lt Bar  gt  f                  5       return 0      Only line  4  compiles without error  Only reinterpret cast can be used to convert a pointer to an object to a pointer to an any unrelated object type   One this to be noted is  The dynamic cast would fail at run-time  however on most compilers it will also fail to compile because there are no virtual functions in the struct of the pointer being casted  meaning dynamic cast will work with only polymorphic class pointers   When to use C   cast    Use static cast as the equivalent of a C-style cast that does value conversion  or when we need to explicitly up-cast a pointer from a class to its superclass  Use const cast to remove the const qualifier    Use reinterpret cast to do unsafe conversions of pointer types to and from integer and other pointer types  Use this only if we know what we are doing and we understand the aliasing issues

User · Answer

static cast is the first cast you should attempt to use  It does things like implicit conversions between types  such as int to float  or pointer to void    and it can also call explicit conversion functions  or implicit ones   In many cases  explicitly stating static cast isn t necessary  but it s important to note that the T something  syntax is equivalent to  T something and should be avoided  more on that later   A T something  something else  is safe  however  and guaranteed to call the constructor   static cast can also cast through inheritance hierarchies  It is unnecessary when casting upwards  towards a base class   but when casting downwards it can be used as long as it doesn t cast through virtual inheritance  It does not do checking  however  and it is undefined behavior to static cast down a hierarchy to a type that isn t actually the type of the object     const cast can be used to remove or add const to a variable  no other C   cast is capable of removing it  not even reinterpret cast   It is important to note that modifying a formerly const value is only undefined if the original variable is const  if you use it to take the const off a reference to something that wasn t declared with const  it is safe  This can be useful when overloading member functions based on const  for instance  It can also be used to add const to an object  such as to call a member function overload   const cast also works similarly on volatile  though that s less common     dynamic cast is exclusively used for handling polymorphism  You can cast a pointer or reference to any polymorphic type to any other class type  a polymorphic type has at least one virtual function  declared or inherited   You can use it for more than just casting downwards     you can cast sideways or even up another chain  The dynamic cast will seek out the desired object and return it if possible  If it can t  it will return nullptr in the case of a pointer  or throw std  bad cast in the case of a reference   dynamic cast has some limitations  though  It doesn t work if there are multiple objects of the same type in the inheritance hierarchy  the so-called  dreaded diamond   and you aren t using virtual inheritance  It also can only go through public inheritance - it will always fail to travel through protected or private inheritance  This is rarely an issue  however  as such forms of inheritance are rare     reinterpret cast is the most dangerous cast  and should be used very sparingly  It turns one type directly into another     such as casting the value from one pointer to another  or storing a pointer in an int  or all sorts of other nasty things  Largely  the only guarantee you get with reinterpret cast is that normally if you cast the result back to the original type  you will get the exact same value  but not if the intermediate type is smaller than the original type   There are a number of conversions that reinterpret cast cannot do  too  It s used primarily for particularly weird conversions and bit manipulations  like turning a raw data stream into actual data  or storing data in the low bits of a pointer to aligned data     C-style cast and function-style cast are casts using  type object or type object   respectively  and are functionally equivalent  They are defined as the first of the following which succeeds    const cast static cast  though ignoring access restrictions  static cast  see above   then const cast reinterpret cast reinterpret cast  then const cast   It can therefore be used as a replacement for other casts in some instances  but can be extremely dangerous because of the ability to devolve into a reinterpret cast  and the latter should be preferred when explicit casting is needed  unless you are sure static cast will succeed or reinterpret cast will fail  Even then  consider the longer  more explicit option   C-style casts also ignore access control when performing a static cast  which means that they have the ability to perform an operation that no other cast can  This is mostly a kludge  though  and in my mind is just another reason to avoid C-style casts

User · Answer

While other answers nicely described all differences between C   casts  I would like to add a short note why you should not use C-style casts  Type  var and Type var    For C   beginners C-style casts look like being the superset operation over C   casts  static cast lt      dynamic cast lt      const cast lt      reinterpret cast lt      and someone could prefer them over the C   casts  In fact C-style cast is the superset and shorter to write   The main problem of C-style casts is that they hide developer real intention of the cast  The C-style casts can do virtually all types of casting from normally safe casts done by static cast lt     and dynamic cast lt     to potentially dangerous casts like const cast lt      where const modifier can be removed so the const variables can be modified and reinterpret cast lt     that can even reinterpret integer values to pointers   Here is the sample   int a rand       Random number   int  pa1 reinterpret cast lt int  gt  a      OK  Here developer clearly expressed he wanted to do this potentially dangerous operation   int  pa2 static cast lt int  gt  a      Compiler error  int  pa3 dynamic cast lt int  gt  a      Compiler error   int  pa4  int   a     OK  C-style cast can do such cast  The question is if it was intentional or developer just did some typo    pa4 5     Program crashes    The main reason why C   casts were added to the language was to allow a developer to clarify his intentions - why he is going to do that cast  By using C-style casts which are perfectly valid in C   you are making your code less readable and more error prone especially for other developers who didn t create your code  So to make your code more readable and explicit you should always prefer C   casts over C-style casts   Here is a short quote from Bjarne Stroustrup s  the author of C    book The C   Programming Language 4th edition - page 302      This C-style cast is far more dangerous than the named conversion operators   because the notation is harder to spot in a large program and the kind of conversion intended by the programmer is not explicit

User · Answer

A lot of theoretical and conceptual explanation has been given above    Below are some of the practical examples when I used static cast  dynamic cast  const cast  reinterpret cast    Also referes this to understand the explaination   http   www cplusplus com doc tutorial typecasting    static cast    OnEventData void  pData                     pData is a void  pData          EventData is a structure e g         typedef struct  EventData         std  string id        std   string remote id          EventData        On Some Situation a void pointer  pData      has been static casted as       EventData  pointer     EventData  evtdata   static cast lt EventData  gt  pData               dynamic cast    void DebugLog  OnMessage Message  msg        static DebugMsgData  debug      static XYZMsgData  xyz       if debug   dynamic cast lt DebugMsgData  gt  msg- gt pdata               debug message           else if xyz   dynamic cast lt XYZMsgData  gt  msg- gt pdata               xyz message           else   if                                    const cast        Passwd declared as a const  const unsigned char  Passwd      on some situation it require to remove its constness  const cast lt unsigned char  gt  Passwd    reinterpret cast    typedef unsigned short uint16      Read Bytes returns that 2 bytes got read    bool ByteBuffer  ReadUInt16 uint16 amp  val      return ReadBytes reinterpret cast lt char  gt   amp val   2

User · Answer

A lot of theoretical and conceptual explanation has been given above    Below are some of the practical examples when I used static cast  dynamic cast  const cast  reinterpret cast    Also referes this to understand the explaination   http   www cplusplus com doc tutorial typecasting    static cast    OnEventData void  pData                     pData is a void  pData          EventData is a structure e g         typedef struct  EventData         std  string id        std   string remote id          EventData        On Some Situation a void pointer  pData      has been static casted as       EventData  pointer     EventData  evtdata   static cast lt EventData  gt  pData               dynamic cast    void DebugLog  OnMessage Message  msg        static DebugMsgData  debug      static XYZMsgData  xyz       if debug   dynamic cast lt DebugMsgData  gt  msg- gt pdata               debug message           else if xyz   dynamic cast lt XYZMsgData  gt  msg- gt pdata               xyz message           else   if                                    const cast        Passwd declared as a const  const unsigned char  Passwd      on some situation it require to remove its constness  const cast lt unsigned char  gt  Passwd    reinterpret cast    typedef unsigned short uint16      Read Bytes returns that 2 bytes got read    bool ByteBuffer  ReadUInt16 uint16 amp  val      return ReadBytes reinterpret cast lt char  gt   amp val   2

User · Answer

Use dynamic cast for converting pointers references within an inheritance hierarchy   Use static cast for ordinary type conversions   Use reinterpret cast for low-level reinterpreting of bit patterns   Use with extreme caution   Use const cast for casting away const volatile   Avoid this unless you are stuck using a const-incorrect API

User · Answer

static cast is the first cast you should attempt to use  It does things like implicit conversions between types  such as int to float  or pointer to void    and it can also call explicit conversion functions  or implicit ones   In many cases  explicitly stating static cast isn t necessary  but it s important to note that the T something  syntax is equivalent to  T something and should be avoided  more on that later   A T something  something else  is safe  however  and guaranteed to call the constructor   static cast can also cast through inheritance hierarchies  It is unnecessary when casting upwards  towards a base class   but when casting downwards it can be used as long as it doesn t cast through virtual inheritance  It does not do checking  however  and it is undefined behavior to static cast down a hierarchy to a type that isn t actually the type of the object     const cast can be used to remove or add const to a variable  no other C   cast is capable of removing it  not even reinterpret cast   It is important to note that modifying a formerly const value is only undefined if the original variable is const  if you use it to take the const off a reference to something that wasn t declared with const  it is safe  This can be useful when overloading member functions based on const  for instance  It can also be used to add const to an object  such as to call a member function overload   const cast also works similarly on volatile  though that s less common     dynamic cast is exclusively used for handling polymorphism  You can cast a pointer or reference to any polymorphic type to any other class type  a polymorphic type has at least one virtual function  declared or inherited   You can use it for more than just casting downwards     you can cast sideways or even up another chain  The dynamic cast will seek out the desired object and return it if possible  If it can t  it will return nullptr in the case of a pointer  or throw std  bad cast in the case of a reference   dynamic cast has some limitations  though  It doesn t work if there are multiple objects of the same type in the inheritance hierarchy  the so-called  dreaded diamond   and you aren t using virtual inheritance  It also can only go through public inheritance - it will always fail to travel through protected or private inheritance  This is rarely an issue  however  as such forms of inheritance are rare     reinterpret cast is the most dangerous cast  and should be used very sparingly  It turns one type directly into another     such as casting the value from one pointer to another  or storing a pointer in an int  or all sorts of other nasty things  Largely  the only guarantee you get with reinterpret cast is that normally if you cast the result back to the original type  you will get the exact same value  but not if the intermediate type is smaller than the original type   There are a number of conversions that reinterpret cast cannot do  too  It s used primarily for particularly weird conversions and bit manipulations  like turning a raw data stream into actual data  or storing data in the low bits of a pointer to aligned data     C-style cast and function-style cast are casts using  type object or type object   respectively  and are functionally equivalent  They are defined as the first of the following which succeeds    const cast static cast  though ignoring access restrictions  static cast  see above   then const cast reinterpret cast reinterpret cast  then const cast   It can therefore be used as a replacement for other casts in some instances  but can be extremely dangerous because of the ability to devolve into a reinterpret cast  and the latter should be preferred when explicit casting is needed  unless you are sure static cast will succeed or reinterpret cast will fail  Even then  consider the longer  more explicit option   C-style casts also ignore access control when performing a static cast  which means that they have the ability to perform an operation that no other cast can  This is mostly a kludge  though  and in my mind is just another reason to avoid C-style casts

User · Answer

Does this answer your question   I have never used reinterpret cast  and wonder whether running into a case that needs it isn t a smell of bad design  In the code base I work on dynamic cast is used a lot  The difference with  static cast is that a dynamic cast does runtime checking which may  safer  or may not  more overhead  be what you want  see msdn

User · Answer

Use dynamic cast for converting pointers references within an inheritance hierarchy   Use static cast for ordinary type conversions   Use reinterpret cast for low-level reinterpreting of bit patterns   Use with extreme caution   Use const cast for casting away const volatile   Avoid this unless you are stuck using a const-incorrect API

User · Answer

static cast is the first cast you should attempt to use  It does things like implicit conversions between types  such as int to float  or pointer to void    and it can also call explicit conversion functions  or implicit ones   In many cases  explicitly stating static cast isn t necessary  but it s important to note that the T something  syntax is equivalent to  T something and should be avoided  more on that later   A T something  something else  is safe  however  and guaranteed to call the constructor   static cast can also cast through inheritance hierarchies  It is unnecessary when casting upwards  towards a base class   but when casting downwards it can be used as long as it doesn t cast through virtual inheritance  It does not do checking  however  and it is undefined behavior to static cast down a hierarchy to a type that isn t actually the type of the object     const cast can be used to remove or add const to a variable  no other C   cast is capable of removing it  not even reinterpret cast   It is important to note that modifying a formerly const value is only undefined if the original variable is const  if you use it to take the const off a reference to something that wasn t declared with const  it is safe  This can be useful when overloading member functions based on const  for instance  It can also be used to add const to an object  such as to call a member function overload   const cast also works similarly on volatile  though that s less common     dynamic cast is exclusively used for handling polymorphism  You can cast a pointer or reference to any polymorphic type to any other class type  a polymorphic type has at least one virtual function  declared or inherited   You can use it for more than just casting downwards     you can cast sideways or even up another chain  The dynamic cast will seek out the desired object and return it if possible  If it can t  it will return nullptr in the case of a pointer  or throw std  bad cast in the case of a reference   dynamic cast has some limitations  though  It doesn t work if there are multiple objects of the same type in the inheritance hierarchy  the so-called  dreaded diamond   and you aren t using virtual inheritance  It also can only go through public inheritance - it will always fail to travel through protected or private inheritance  This is rarely an issue  however  as such forms of inheritance are rare     reinterpret cast is the most dangerous cast  and should be used very sparingly  It turns one type directly into another     such as casting the value from one pointer to another  or storing a pointer in an int  or all sorts of other nasty things  Largely  the only guarantee you get with reinterpret cast is that normally if you cast the result back to the original type  you will get the exact same value  but not if the intermediate type is smaller than the original type   There are a number of conversions that reinterpret cast cannot do  too  It s used primarily for particularly weird conversions and bit manipulations  like turning a raw data stream into actual data  or storing data in the low bits of a pointer to aligned data     C-style cast and function-style cast are casts using  type object or type object   respectively  and are functionally equivalent  They are defined as the first of the following which succeeds    const cast static cast  though ignoring access restrictions  static cast  see above   then const cast reinterpret cast reinterpret cast  then const cast   It can therefore be used as a replacement for other casts in some instances  but can be extremely dangerous because of the ability to devolve into a reinterpret cast  and the latter should be preferred when explicit casting is needed  unless you are sure static cast will succeed or reinterpret cast will fail  Even then  consider the longer  more explicit option   C-style casts also ignore access control when performing a static cast  which means that they have the ability to perform an operation that no other cast can  This is mostly a kludge  though  and in my mind is just another reason to avoid C-style casts

[c++] When should static_cast, dynamic_cast, const_cast and reinterpret_cast be used?

Examples related to c++

Examples related to pointers

Examples related to casting

Examples related to c++-faq