dynamic cast and static cast in C

Question

I am quite confused with the dynamic cast keyword in C     struct A       virtual void f          struct B   public A      struct C       void f          A a      B b       A  ap    amp b      B  b1   dynamic cast lt B  gt    amp a       NULL  because  a  is not a  B      B  b2   dynamic cast lt B  gt   ap        b      C  c   dynamic cast lt C  gt   ap        NULL       A amp  ar   dynamic cast lt A amp  gt    ap      Ok      B amp  br   dynamic cast lt B amp  gt    ap      Ok      C amp  cr   dynamic cast lt C amp  gt    ap      std  bad cast     the definition says         The dynamic cast keyword casts a datum from one pointer or reference        type to another  performing a runtime check to ensure the validity of the cast   Can we write an equivalent of dynamic cast of C   in C so that I could better understand things

User · Answer

A dynamic cast performs a type checking using RTTI  If it fails it ll throw you an exception  if you gave it a reference  or NULL if you gave it a pointer

User · Answer

First  to describe dynamic cast in C terms  we have to represent classes in C  Classes with virtual functions use a  VTABLE  of pointers to the virtual functions  Comments are C    Feel free to reformat and fix compile errors        class A   public  int data  virtual int GetData   return data      typedef struct A   void  vtable  int data   A  int AGetData A this   return this- gt data    void   Avtable        void  AGetData    A   newA     A res   malloc sizeof A    res- gt vtable   Avtable  return res        class B   public class A   public  int moredata  virtual int GetData   return data 1     typedef struct B   void  vtable  int data  int moredata    B  int BGetData B this   return this- gt data   1    void   Bvtable        void  BGetData    B   newB     B res   malloc sizeof B    res- gt vtable   Bvtable  return res        int temp   ptr- gt GetData    int temp     int      ptr- gt vtable 0        Then a dynamic cast is something like      A   ptr   new B    A   ptr    A   newB       B   aB   dynamic cast lt B gt  ptr   B   aB     ptr- gt vtable    Bvtable    B   aB    B   0

User · Answer

More than code in C  I think that an english definition could be enough   Given a class Base of which there is a derived class Derived  dynamic cast will convert a Base pointer to a Derived pointer if and only if the actual object pointed at is in fact a Derived object   class Base   virtual  Base         class Derived   public Base     class Derived2   public Base     class ReDerived   public Derived      void test  Base  amp  base        dynamic cast lt Derived amp  gt  base      int main        Base b     Derived d     Derived2 d2     ReDerived rd      test  b         throw  b is not a Derived object    test  d         ok    test  d2        throw  d2 is not a Derived object    test  rd        ok  rd is a ReDerived  and thus a derived object     In the example  the call to test binds different objects to a reference to Base  Internally the reference is downcasted to a reference to Derived in a typesafe way  the downcast will succeed only for those cases where the referenced object is indeed an instance of Derived

User · Answer

Unless you re implementing your own hand-rolled RTTI  and bypassing the system one   it s not possible to implement dynamic cast directly in C   user-level code  dynamic cast is very much tied into the C   implementation s RTTI system   But  to help you understand RTTI  and thus dynamic cast  more  you should read up on the  lt typeinfo gt  header  and the typeid operator  This returns the type info corresponding to the object you have at hand  and you can inquire various  limited  things from these type info objects

User · Answer

There are no classes in C  so it s impossible to to write dynamic cast in that language  C structures don t have methods  as a result  they don t have virtual methods   so there is nothing  dynamic  in it

User · Answer

Here s a rundown on static cast lt  gt  and dynamic cast lt  gt  specifically as they pertain to pointers   This is just a 101-level rundown  it does not cover all the intricacies  static cast lt  Type   gt  ptr  This takes the pointer in ptr and tries to safely cast it to a pointer of type Type    This cast is done at compile time   It will only perform the cast if the types are related   If the types are not related  you will get a compiler error   For example  class B     class D   public B     class X      int main       D  d   new D    B  b   static cast lt B  gt  d      this works   X  x   static cast lt X  gt  d      ERROR - Won t compile   return 0     dynamic cast lt  Type   gt  ptr  This again tries to take the pointer in ptr and safely cast it to a pointer of type Type    But this cast is executed at runtime  not compile time   Because this is a run-time cast  it is useful especially when combined with polymorphic classes   In fact  in certian cases the classes must be polymorphic in order for the cast to be legal  Casts can go in one of two directions   from base to derived  B2D  or from derived to base  D2B    It s simple enough to see how D2B casts would work at runtime   Either ptr was derived from Type or it wasn t   In the case of D2B dynamic cast lt  gt s  the rules are simple   You can try to cast anything to anything else  and if ptr was in fact derived from Type  you ll get a Type  pointer back from dynamic cast   Otherwise  you ll get a NULL pointer  But B2D casts are a little more complicated   Consider the following code   include  lt iostream gt  using namespace std   class Base   public      virtual void DoIt     0        pure virtual     virtual  Base           class Foo   public Base   public      virtual void DoIt     cout  lt  lt   quot Foo quot           void FooIt     cout  lt  lt   quot Fooing It    quot         class Bar   public Base   public       virtual void DoIt     cout  lt  lt   quot Bar quot         void BarIt     cout  lt  lt   quot baring It    quot         Base  CreateRandom         if   rand   2     0           return new Foo      else         return new Bar      int main         for  int n   0  n  lt  10    n                 Base  base   CreateRandom                 base- gt DoIt             Bar  bar    Bar  base          bar- gt BarIt            return 0     main   can t tell what kind of object CreateRandom   will return  so the C-style cast Bar  bar    Bar  base  is decidedly not type-safe   How could you fix this   One way would be to add a function like bool AreYouABar   const   0  to the base class and return true from Bar and false from Foo   But there is another way  use dynamic cast lt  gt   int main         for  int n   0  n  lt  10    n                 Base  base   CreateRandom             base- gt DoIt             Bar  bar   dynamic cast lt Bar  gt  base           Foo  foo   dynamic cast lt Foo  gt  base           if  bar               bar- gt BarIt            if  foo               foo- gt FooIt            return 0      The casts execute at runtime  and work by querying the object  no need to worry about how for now   asking it if it the type we re looking for   If it is  dynamic cast lt Type  gt  returns a pointer  otherwise it returns NULL  In order for this base-to-derived casting to work using dynamic cast lt  gt   Base  Foo and Bar must be what the Standard calls polymorphic types   In order to be a polymorphic type  your class must have at least one virtual function   If your classes are not polymorphic types  the base-to-derived use of dynamic cast will not compile   Example  class Base     class Der   public Base       int main         Base  base   new Der      Der  der   dynamic cast lt Der  gt  base      ERROR - Won t compile      return 0     Adding a virtual function to base  such as a virtual dtor  will make both Base and Der polymorphic types  class Base    public      virtual  Base         class Der   public Base       int main         Base  base   new Der      Der  der   dynamic cast lt Der  gt  base      OK      return 0

User · Answer

No  not easily   The compiler assigns a unique identity to every class  that information is referenced by every object instance  and that is what gets inspected at runtime to determine if a dynamic cast is legal   You could create a standard base class with this information and operators to do the runtime inspection on that base class  then any derived class would inform the base class of its place in the class hierarchy and any instances of those classes would be runtime-castable via your operations   edit  Here s an implementation that demonstrates one technique   I m not claiming the compiler uses anything like this  but I think it demonstrates the concepts   class SafeCastableBase   public      typedef long TypeID      static TypeID s nextTypeID      static TypeID GetNextTypeID                 return s nextTypeID              static TypeID GetTypeID                 return 0            virtual bool CanCastTo TypeID id                if  GetTypeID      id    return false            return true            template  lt class Target gt      static Target  SafeCast SafeCastableBase  pSource                if  pSource- gt CanCastTo Target  GetTypeID                           return  Target  pSource                    return NULL           SafeCastableBase  TypeID SafeCastableBase  s nextTypeID   1   class TypeIDInitializer   public      TypeIDInitializer SafeCastableBase  TypeID  pTypeID                 pTypeID   SafeCastableBase  GetNextTypeID              class ChildCastable   public SafeCastableBase   public      static TypeID s typeID      static TypeID GetTypeID                 return s typeID            virtual bool CanCastTo TypeID id                if  GetTypeID      id    return SafeCastableBase  CanCastTo id             return true           SafeCastableBase  TypeID ChildCastable  s typeID   TypeIDInitializer ChildCastableInitializer  amp ChildCastable  s typeID    class PeerChildCastable   public SafeCastableBase   public      static TypeID s typeID      static TypeID GetTypeID                 return s typeID            virtual bool CanCastTo TypeID id                if  GetTypeID      id    return SafeCastableBase  CanCastTo id             return true           SafeCastableBase  TypeID PeerChildCastable  s typeID   TypeIDInitializer PeerChildCastableInitializer  amp PeerChildCastable  s typeID    int  tmain int argc   TCHAR  argv          ChildCastable  pChild   new ChildCastable        SafeCastableBase  pBase   new SafeCastableBase        PeerChildCastable  pPeerChild   new PeerChildCastable        ChildCastable  pSameChild   SafeCastableBase  SafeCast lt ChildCastable gt  pChild       SafeCastableBase  pBaseToChild   SafeCastableBase  SafeCast lt SafeCastableBase gt  pChild       ChildCastable  pNullDownCast   SafeCastableBase  SafeCast lt ChildCastable gt  pBase       SafeCastableBase  pBaseToPeerChild   SafeCastableBase  SafeCast lt SafeCastableBase gt  pPeerChild       ChildCastable  pNullCrossCast   SafeCastableBase  SafeCast lt ChildCastable gt  pPeerChild       return 0

User · Answer

dynamic cast uses RTTI  It can slow down your application  you can use modification of the visitor design pattern to achieve downcasting without RTTI http   arturx64 github io programming-world 2016 02 06 lazy-visitor html

User · Answer

The following is not really close to what you get from C   s dynamic cast in terms of type checking but maybe it will help you understand its purpose a little bit better   struct Animal    Would be a base class in C         enum Type   Dog  Cat        Type type      Animal   make dog        Animal   dog   new Animal     dog- gt type   Animal  Dog     return dog    Animal   make cat        Animal   cat   new Animal     cat- gt type   Animal  Cat     return cat     Animal   dyn cast AnimalType type  Animal   animal        if animal- gt type    type          return animal      return 0     void bark Animal   dog        assert dog- gt type    Animal  Dog           make  dog  bark    int main         Animal   animal      if rand     2          animal   make dog        else         animal   make cat            At this point we have no idea what kind of animal we have        so we use dyn cast to see if it s a dog      if dyn cast Animal  Dog  animal                 bark animal      we are sure the call is safe            delete animal

User · Answer

static cast lt  Type   gt  ptr   static cast in C   can be used in scenarios where all type casting can be verified at compile time   dynamic cast lt  Type   gt  ptr   dynamic cast in C   can be used to perform type safe down casting  dynamic cast is run time polymorphism  The dynamic cast operator  which safely converts from a pointer  or reference  to a base type to a pointer  or reference  to a derived type   eg 1    include  lt iostream gt  using namespace std   class A   public      virtual void f   cout  lt  lt   A  f     lt  lt  endl       class B   public A   public      void f   cout  lt  lt   B  f     lt  lt  endl       int main         A a      B b      a f              A  f       b f              B  f        A  pA    amp a         B  pB    amp b         pA- gt f            A  f       pB- gt f            B  f        pA    amp b         pB    amp a          not allowed     pB   dynamic cast lt B  gt   amp a      allowed but it returns NULL      return 0      For more information click here  eg 2    include  lt iostream gt   using namespace std   class A   public      virtual void print  const  cout  lt  lt    A n        class B   public      virtual void print  const  cout  lt  lt    B n        class C  public A  public B   public      void print  const  cout  lt  lt    C n         int main          A  a   new A      B  b   new B      C  c   new C       a - gt  print    b - gt  print    c - gt  print        b   dynamic cast lt  B  gt  a      fails     if  b           b - gt  print          else         cout  lt  lt   no B n       a   c      a - gt  print      C prints     b   dynamic cast lt  B  gt  a      succeeds     if  b         b - gt  print          else         cout  lt  lt   no B n

[c++] dynamic_cast and static_cast in C++

Examples related to c++

Examples related to casting

Examples related to dynamic-cast