Regular cast vs static cast vs dynamic cast

Question

I ve been writing C and C   code for almost twenty years  but there s one aspect of these languages that I ve never really understood  I ve obviously used regular casts i e   MyClass  m    MyClass   ptr    all over the place  but there seem to be two other types of casts  and I don t know the difference  What s the difference between the following lines of code   MyClass  m    MyClass   ptr  MyClass  m   static cast lt MyClass   gt  ptr   MyClass  m   dynamic cast lt MyClass   gt  ptr

User · Answer

FYI  I believe Bjarne Stroustrup is quoted as saying that C-style casts are to be avoided and that you should use static cast or dynamic cast if at all possible   Barne Stroustrup s C   style FAQ  Take that advice for what you will   I m far from being a C   guru

User · Answer

Static cast    The static cast performs conversions between compatible types  It is similar to the C-style cast  but is more restrictive  For example  the C-style cast would allow an integer pointer to point to a char  char c   10           1 byte int  p    int   amp c     4 bytes  Since this results in a 4-byte pointer pointing to 1 byte of allocated memory  writing to this pointer will either cause a run-time error or will overwrite some adjacent memory   p   5     run-time error  stack corruption  In contrast to the C-style cast  the static cast will allow the compiler to check that the pointer and pointee data types are compatible  which allows the programmer to catch this incorrect pointer assignment during compilation  int  q   static cast lt int  gt   amp c      compile-time error  Reinterpret cast To force the pointer conversion  in the same way as the C-style cast does in the background  the reinterpret cast would be used instead  int  r   reinterpret cast lt int  gt   amp c      forced conversion  This cast handles conversions between certain unrelated types  such as from one pointer type to another incompatible pointer type  It will simply perform a binary copy of the data without altering the underlying bit pattern  Note that the result of such a low-level operation is system-specific and therefore not portable  It should be used with caution if it cannot be avoided altogether  Dynamic cast This one is only used to convert object pointers and object references into other pointer or reference types in the inheritance hierarchy  It is the only cast that makes sure that the object pointed to can be converted  by performing a run-time check that the pointer refers to a complete object of the destination type  For this run-time check to be possible the object must be polymorphic  That is  the class must define or inherit at least one virtual function  This is because the compiler will only generate the needed run-time type information for such objects  Dynamic cast examples In the example below  a MyChild pointer is converted into a MyBase pointer using a dynamic cast  This derived-to-base conversion succeeds  because the Child object includes a complete Base object  class MyBase       public    virtual void test         class MyChild   public MyBase        int main       MyChild  child   new MyChild      MyBase   base   dynamic cast lt MyBase  gt  child      ok    The next example attempts to convert a MyBase pointer to a MyChild pointer  Since the Base object does not contain a complete Child object this pointer conversion will fail  To indicate this  the dynamic cast returns a null pointer  This gives a convenient way to check whether or not a conversion has succeeded during run-time  MyBase   base   new MyBase    MyChild  child   dynamic cast lt MyChild  gt  base      if  child    0   std  cout  lt  lt   quot Null pointer returned quot    If a reference is converted instead of a pointer  the dynamic cast will then fail by throwing a bad cast exception  This needs to be handled using a try-catch statement   include  lt exception gt           try      MyChild  amp child   dynamic cast lt MyChild amp  gt   base     catch std  bad cast  amp e        std  cout  lt  lt  e what       bad dynamic cast    Dynamic or static cast The advantage of using a dynamic cast is that it allows the programmer to check whether or not a conversion has succeeded during run-time  The disadvantage is that there is a performance overhead associated with doing this check  For this reason using a static cast would have been preferable in the first example  because a derived-to-base conversion will never fail  MyBase  base   static cast lt MyBase  gt  child      ok  However  in the second example the conversion may either succeed or fail  It will fail if the MyBase object contains a MyBase instance and it will succeed if it contains a MyChild instance  In some situations this may not be known until run-time  When this is the case dynamic cast is a better choice than static cast     Succeeds for a MyChild object MyChild  child   dynamic cast lt MyChild  gt  base    If the base-to-derived conversion had been performed using a static cast instead of a dynamic cast the conversion would not have failed  It would have returned a pointer that referred to an incomplete object  Dereferencing such a pointer can lead to run-time errors     Allowed  but invalid MyChild  child   static cast lt MyChild  gt  base        Incomplete MyChild object dereferenced   child    Const cast This one is primarily used to add or remove the const modifier of a variable  const int myConst   5  int  nonConst   const cast lt int  gt   amp myConst      removes const  Although const cast allows the value of a constant to be changed  doing so is still invalid code that may cause a run-time error  This could occur for example if the constant was located in a section of read-only memory   nonConst   10     potential run-time error  Const cast is instead used mainly when there is a function that takes a non-constant pointer argument  even though it does not modify the pointee  void print int  p        std  cout  lt  lt   p     The function can then be passed a constant variable by using a const cast  print  amp myConst      error  cannot convert                      const int  to int    print nonConst      allowed  Source and More Explanations

User · Answer

Avoid using C-Style casts   C-style casts are a mix of const and reinterpret cast  and it s difficult to find-and-replace in your code  A C   application programmer should avoid C-style cast

User · Answer

You should look at the article C   Programming Type Casting   It contains a good description of all of the different cast types  The following taken from the above link      const cast      const cast expression  The const cast lt     is used to add remove   const ness   or volatile-ness  of a variable       static cast      static cast expression  The static cast lt     is used to cast between   the integer types   e g   char- long  int- short etc       Static cast is also used to cast pointers to related types  for   example casting void  to the appropriate type       dynamic cast      Dynamic cast is used to convert pointers and references at run-time    generally for the purpose of casting a pointer or reference up or down   an inheritance chain  inheritance hierarchy        dynamic cast expression       The target type must be a pointer or reference type  and the   expression must evaluate to a pointer or reference  Dynamic cast works   only when the type of object to which the expression refers is   compatible with the target type and the base class has at least one   virtual member function  If not  and the type of expression being cast   is a pointer  NULL is returned  if a dynamic cast on a reference   fails  a bad cast exception is thrown  When it doesn t fail  dynamic   cast returns a pointer or reference of the target type to the object   to which expression referred       reinterpret cast      Reinterpret cast simply casts one type bitwise to another  Any pointer   or integral type can be casted to any other with reinterpret cast    easily allowing for misuse  For instance  with reinterpret cast one   might  unsafely  cast an integer pointer to a string pointer

User · Answer

C-style casts conflate const cast  static cast  and reinterpret cast   I wish C   didn t have C-style casts   C   casts stand out properly  as they should  casts are normally indicative of doing something bad  and properly distinguish between the different kinds of conversion that casts perform   They also permit similar-looking functions to be written  e g  boost  lexical cast  which is quite nice from a consistency perspective

User · Answer

dynamic cast has runtime type checking and only works with references and pointers  whereas static cast does not offer runtime type checking  For complete information  see the MSDN article static cast Operator

User · Answer

dynamic cast only supports pointer and reference types  It returns NULL if the cast is impossible if the type is a pointer or throws an exception if the type is a reference type  Hence  dynamic cast can be used to check if an object is of a given type  static cast cannot  you will simply end up with an invalid value    C-style  and other  casts have been covered in the other answers

User · Answer

static cast  static cast is used for cases where you basically want to reverse an implicit conversion  with a few restrictions and additions  static cast performs no runtime checks  This should be used if you know that you refer to an object of a specific type  and thus a check would be unnecessary  Example   void func void  data         Conversion from MyClass  - gt  void  is implicit   MyClass  c   static cast lt MyClass  gt  data            int main       MyClass c    start thread  amp func   amp c      func  amp c  will be called        join        In this example  you know that you passed a MyClass object  and thus there isn t any need for a runtime check to ensure this   dynamic cast  dynamic cast is useful when you don t know what the dynamic type of the object is  It returns a null pointer if the object referred to doesn t contain the type casted to as a base class  when you cast to a reference  a bad cast exception is thrown in that case    if  JumpStm  j   dynamic cast lt JumpStm  gt   amp stm             else if  ExprStm  e   dynamic cast lt ExprStm  gt   amp stm               You cannot use dynamic cast if you downcast  cast to a derived class  and the argument type is not polymorphic  For example  the following code is not valid  because Base doesn t contain any virtual function   struct Base      struct Derived   Base      int main       Derived d  Base  b    amp d    dynamic cast lt Derived  gt  b      Invalid     An  up-cast   cast to the base class  is always valid with both static cast and dynamic cast  and also without any cast  as an  up-cast  is an implicit conversion   Regular Cast  These casts are also called C-style cast  A C-style cast is basically identical to trying out a range of sequences of C   casts  and taking the first C   cast that works  without ever considering dynamic cast  Needless to say  this is much more powerful as it combines all of const cast  static cast and reinterpret cast  but it s also unsafe  because it does not use dynamic cast   In addition  C-style casts not only allow you to do this  but they also allow you to safely cast to a private base-class  while the  equivalent  static cast sequence would give you a compile-time error for that   Some people prefer C-style casts because of their brevity  I use them for numeric casts only  and use the appropriate C   casts when user defined types are involved  as they provide stricter checking

[c++] Regular cast vs. static_cast vs. dynamic_cast

Examples related to c++

Examples related to pointers

Examples related to casting