C equivalent of java s instanceof

Question

What is the preferred method to achieve the C   equivalent of java s instanceof

User · Answer

include  lt iostream h gt   include lt typeinfo h gt   template lt class T gt  void fun T a      if typeid T     typeid int              Do something      cout lt  lt  int         else if typeid T     typeid float              Do Something else      cout lt  lt  float          void main            fun 23         fun 90 67f

User · Answer

dynamic cast is known to be inefficient  It traverses up the inheritance hierarchy  and it is the only solution if you have multiple levels of inheritance  and need to check if an object is an instance of any one of the types in its type hierarchy   But if a more limited form of instanceof that only checks if an object is exactly the type you specify  suffices for your needs  the function below would be a lot more efficient   template lt typename T  typename K gt  inline bool isType const K  amp k        return typeid T  hash code      typeid k  hash code        Here s an example of how you d invoke the function above   DerivedA k  Base  p    amp k   cout  lt  lt  boolalpha  lt  lt  isType lt DerivedA gt   p   lt  lt  endl      true cout  lt  lt  boolalpha  lt  lt  isType lt DerivedB gt   p   lt  lt  endl      false   You d specify template type A  as the type you re checking for   and pass in the object you want to test as the argument  from which template type K would be inferred

User · Answer

Instanceof implementation without dynamic cast  I think this question is still relevant today  Using the C  11 standard you are now able to implement a instanceof function without using dynamic cast like this   if  dynamic cast lt B  gt  aPtr     nullptr         aPtr is instance of B   else        aPtr is NOT instance of B     But you re still reliant on RTTI support  So here is my solution for this problem depending on some Macros and Metaprogramming Magic  The only drawback imho is that this approach does not work for multiple inheritance   InstanceOfMacros h   include  lt set gt   include  lt tuple gt   include  lt typeindex gt    define  EMPTY BASE TYPE DECL   using BaseTypes   std  tuple lt  gt    define  BASE TYPE DECL Class  BaseClass      using BaseTypes   decltype std  tuple cat std  tuple lt BaseClass gt     Class  BaseTypes       define  INSTANCE OF DECL BODY Class                                      static const std  set lt std  type index gt  baseTypeContainer                virtual bool instanceOfHelper const std  type index  amp  tidx                if  std  type index typeid ThisType       tidx  return true             if  std  tuple size lt BaseTypes gt   value    0  return false                return baseTypeContainer find  tidx     baseTypeContainer end                                                                                 template  lt typename    T gt                                                 static std  set lt std  type index gt  getTypeIndexes std  tuple lt T    gt           return std  set lt std  type index gt  std  type index typeid T                 define INSTANCE OF SUB DECL Class  BaseClass     protected                                         using ThisType   Class                            BASE TYPE DECL Class  BaseClass                  INSTANCE OF DECL BODY Class    define INSTANCE OF BASE DECL Class                                                        protected                                                                                  using ThisType   Class                                                                     EMPTY BASE TYPE DECL                                                                      INSTANCE OF DECL BODY Class                                                             public                                                                                     template  lt typename Of gt                                                                     typename std  enable if lt std  is base of lt Class  Of gt   value  bool gt   type instanceOf           return instanceOfHelper std  type index typeid Of                                           define INSTANCE OF IMPL Class      const std  set lt std  type index gt  Class  baseTypeContainer   Class  getTypeIndexes Class  BaseTypes       Demo  You can then use this stuff  with caution  as follows   DemoClassHierarchy hpp    include  InstanceOfMacros h   struct A     virtual  A        INSTANCE OF BASE DECL A     INSTANCE OF IMPL A   struct B   public A     virtual  B        INSTANCE OF SUB DECL B  A     INSTANCE OF IMPL B   struct C   public A     virtual  C        INSTANCE OF SUB DECL C  A     INSTANCE OF IMPL C   struct D   public C     virtual  D        INSTANCE OF SUB DECL D  C     INSTANCE OF IMPL D    The following code presents a small demo to verify rudimentary the correct behavior   InstanceOfDemo cpp   include  lt iostream gt   include  lt memory gt   include  DemoClassHierarchy hpp   int main       A  a2aPtr   new A    A  a2bPtr   new B    std  shared ptr lt A gt  a2cPtr new C     C  c2dPtr   new D    std  unique ptr lt A gt  a2dPtr new D      std  cout  lt  lt   a2aPtr- gt instanceOf lt A gt     expected 1  value    lt  lt  a2aPtr- gt instanceOf lt A gt     lt  lt  std  endl    std  cout  lt  lt   a2aPtr- gt instanceOf lt B gt     expected 0  value    lt  lt  a2aPtr- gt instanceOf lt B gt     lt  lt  std  endl    std  cout  lt  lt   a2aPtr- gt instanceOf lt C gt     expected 0  value    lt  lt  a2aPtr- gt instanceOf lt C gt     lt  lt  std  endl    std  cout  lt  lt   a2aPtr- gt instanceOf lt D gt     expected 0  value    lt  lt  a2aPtr- gt instanceOf lt D gt     lt  lt  std  endl    std  cout  lt  lt  std  endl    std  cout  lt  lt   a2bPtr- gt instanceOf lt A gt     expected 1  value    lt  lt  a2bPtr- gt instanceOf lt A gt     lt  lt  std  endl    std  cout  lt  lt   a2bPtr- gt instanceOf lt B gt     expected 1  value    lt  lt  a2bPtr- gt instanceOf lt B gt     lt  lt  std  endl    std  cout  lt  lt   a2bPtr- gt instanceOf lt C gt     expected 0  value    lt  lt  a2bPtr- gt instanceOf lt C gt     lt  lt  std  endl    std  cout  lt  lt   a2bPtr- gt instanceOf lt D gt     expected 0  value    lt  lt  a2bPtr- gt instanceOf lt D gt     lt  lt  std  endl    std  cout  lt  lt  std  endl    std  cout  lt  lt   a2cPtr- gt instanceOf lt A gt     expected 1  value    lt  lt  a2cPtr- gt instanceOf lt A gt     lt  lt  std  endl    std  cout  lt  lt   a2cPtr- gt instanceOf lt B gt     expected 0  value    lt  lt  a2cPtr- gt instanceOf lt B gt     lt  lt  std  endl    std  cout  lt  lt   a2cPtr- gt instanceOf lt C gt     expected 1  value    lt  lt  a2cPtr- gt instanceOf lt C gt     lt  lt  std  endl    std  cout  lt  lt   a2cPtr- gt instanceOf lt D gt     expected 0  value    lt  lt  a2cPtr- gt instanceOf lt D gt     lt  lt  std  endl    std  cout  lt  lt  std  endl    std  cout  lt  lt   c2dPtr- gt instanceOf lt A gt     expected 1  value    lt  lt  c2dPtr- gt instanceOf lt A gt     lt  lt  std  endl    std  cout  lt  lt   c2dPtr- gt instanceOf lt B gt     expected 0  value    lt  lt  c2dPtr- gt instanceOf lt B gt     lt  lt  std  endl    std  cout  lt  lt   c2dPtr- gt instanceOf lt C gt     expected 1  value    lt  lt  c2dPtr- gt instanceOf lt C gt     lt  lt  std  endl    std  cout  lt  lt   c2dPtr- gt instanceOf lt D gt     expected 1  value    lt  lt  c2dPtr- gt instanceOf lt D gt     lt  lt  std  endl    std  cout  lt  lt  std  endl    std  cout  lt  lt   a2dPtr- gt instanceOf lt A gt     expected 1  value    lt  lt  a2dPtr- gt instanceOf lt A gt     lt  lt  std  endl    std  cout  lt  lt   a2dPtr- gt instanceOf lt B gt     expected 0  value    lt  lt  a2dPtr- gt instanceOf lt B gt     lt  lt  std  endl    std  cout  lt  lt   a2dPtr- gt instanceOf lt C gt     expected 1  value    lt  lt  a2dPtr- gt instanceOf lt C gt     lt  lt  std  endl    std  cout  lt  lt   a2dPtr- gt instanceOf lt D gt     expected 1  value    lt  lt  a2dPtr- gt instanceOf lt D gt     lt  lt  std  endl     delete a2aPtr    delete a2bPtr    delete c2dPtr     return 0      Output   a2aPtr- gt instanceOf lt A gt     expected 1  value 1 a2aPtr- gt instanceOf lt B gt     expected 0  value 0 a2aPtr- gt instanceOf lt C gt     expected 0  value 0 a2aPtr- gt instanceOf lt D gt     expected 0  value 0  a2bPtr- gt instanceOf lt A gt     expected 1  value 1 a2bPtr- gt instanceOf lt B gt     expected 1  value 1 a2bPtr- gt instanceOf lt C gt     expected 0  value 0 a2bPtr- gt instanceOf lt D gt     expected 0  value 0  a2cPtr- gt instanceOf lt A gt     expected 1  value 1 a2cPtr- gt instanceOf lt B gt     expected 0  value 0 a2cPtr- gt instanceOf lt C gt     expected 1  value 1 a2cPtr- gt instanceOf lt D gt     expected 0  value 0  c2dPtr- gt instanceOf lt A gt     expected 1  value 1 c2dPtr- gt instanceOf lt B gt     expected 0  value 0 c2dPtr- gt instanceOf lt C gt     expected 1  value 1 c2dPtr- gt instanceOf lt D gt     expected 1  value 1  a2dPtr- gt instanceOf lt A gt     expected 1  value 1 a2dPtr- gt instanceOf lt B gt     expected 0  value 0 a2dPtr- gt instanceOf lt C gt     expected 1  value 1 a2dPtr- gt instanceOf lt D gt     expected 1  value 1   Performance  The most interesting question which now arises is  if this evil stuff is more efficient than the usage of dynamic cast  Therefore I ve written a very basic performance measurement app   InstanceOfPerformance cpp   include  lt chrono gt   include  lt iostream gt   include  lt string gt   include  DemoClassHierarchy hpp   template  lt typename Base  typename Derived  typename Duration gt  Duration instanceOfMeasurement unsigned  loopCycles      auto start   std  chrono  high resolution clock  now      volatile bool isInstanceOf   false    for  unsigned i   0  i  lt   loopCycles    i        Base  ptr   new Derived      isInstanceOf   ptr- gt template instanceOf lt Derived gt         delete ptr        auto end   std  chrono  high resolution clock  now      return std  chrono  duration cast lt Duration gt  end - start      template  lt typename Base  typename Derived  typename Duration gt  Duration dynamicCastMeasurement unsigned  loopCycles      auto start   std  chrono  high resolution clock  now      volatile bool isInstanceOf   false    for  unsigned i   0  i  lt   loopCycles    i        Base  ptr   new Derived      isInstanceOf   dynamic cast lt Derived   gt  ptr     nullptr      delete ptr        auto end   std  chrono  high resolution clock  now      return std  chrono  duration cast lt Duration gt  end - start      int main       unsigned testCycles   10000000    std  string unit     us     using DType   std  chrono  microseconds     std  cout  lt  lt   InstanceOf performance A- gt D        lt  lt  instanceOfMeasurement lt A  D  DType gt  testCycles  count    lt  lt  unit              lt  lt  std  endl    std  cout  lt  lt   InstanceOf performance A- gt C        lt  lt  instanceOfMeasurement lt A  C  DType gt  testCycles  count    lt  lt  unit              lt  lt  std  endl    std  cout  lt  lt   InstanceOf performance A- gt B        lt  lt  instanceOfMeasurement lt A  B  DType gt  testCycles  count    lt  lt  unit              lt  lt  std  endl    std  cout  lt  lt   InstanceOf performance A- gt A        lt  lt  instanceOfMeasurement lt A  A  DType gt  testCycles  count    lt  lt  unit              lt  lt    n               lt  lt  std  endl    std  cout  lt  lt   DynamicCast performance A- gt D       lt  lt  dynamicCastMeasurement lt A  D  DType gt  testCycles  count    lt  lt  unit              lt  lt  std  endl    std  cout  lt  lt   DynamicCast performance A- gt C       lt  lt  dynamicCastMeasurement lt A  C  DType gt  testCycles  count    lt  lt  unit              lt  lt  std  endl    std  cout  lt  lt   DynamicCast performance A- gt B       lt  lt  dynamicCastMeasurement lt A  B  DType gt  testCycles  count    lt  lt  unit              lt  lt  std  endl    std  cout  lt  lt   DynamicCast performance A- gt A       lt  lt  dynamicCastMeasurement lt A  A  DType gt  testCycles  count    lt  lt  unit              lt  lt    n               lt  lt  std  endl    return 0      The results vary and are essentially based on the degree of compiler optimization  Compiling the performance measurement program using g   -std c  11 -O0 -o instanceof-performance InstanceOfPerformance cpp the output on my local machine was   InstanceOf performance A- gt D     699638 us InstanceOf performance A- gt C     642157 us InstanceOf performance A- gt B     671399 us InstanceOf performance A- gt A     626193 us  DynamicCast performance A- gt D    754937 us DynamicCast performance A- gt C    706766 us DynamicCast performance A- gt B    751353 us DynamicCast performance A- gt A    676853 us   Mhm  this result was very sobering  because the timings demonstrates that the new approach is not much faster compared to the dynamic cast approach  It is even less efficient for the special test case which tests if a pointer of A is an instance ofA  BUT the tide turns by tuning our binary using compiler otpimization  The respective compiler command is g   -std c  11 -O3 -o instanceof-performance InstanceOfPerformance cpp  The result on my local machine was amazing   InstanceOf performance A- gt D     3035 us InstanceOf performance A- gt C     5030 us InstanceOf performance A- gt B     5250 us InstanceOf performance A- gt A     3021 us  DynamicCast performance A- gt D    666903 us DynamicCast performance A- gt C    698567 us DynamicCast performance A- gt B    727368 us DynamicCast performance A- gt A    3098 us   If you are not reliant on multiple inheritance  are no opponent of good old C macros  RTTI and template metaprogramming and are not too lazy to add some small instructions to the classes of your class hierarchy  then this approach can boost your application a little bit with respect to its performance  if you often end up with checking the instance of a pointer  But use it with caution  There is no warranty for the correctness of this approach   Note  All demos were compiled using clang  Apple LLVM version 9 0 0  clang-900 0 39 2   under macOS Sierra on a MacBook Pro Mid 2012   Edit  I ve also tested the performance on a Linux machine using gcc  Ubuntu 5 4 0-6ubuntu1 16 04 9  5 4 0 20160609  On this platform the perfomance benefit was not so significant as on macOs with clang   Output  without compiler optimization    InstanceOf performance A- gt D     390768 us InstanceOf performance A- gt C     333994 us InstanceOf performance A- gt B     334596 us InstanceOf performance A- gt A     300959 us  DynamicCast performance A- gt D    331942 us DynamicCast performance A- gt C    303715 us DynamicCast performance A- gt B    400262 us DynamicCast performance A- gt A    324942 us   Output  with compiler optimization    InstanceOf performance A- gt D     209501 us InstanceOf performance A- gt C     208727 us InstanceOf performance A- gt B     207815 us InstanceOf performance A- gt A     197953 us  DynamicCast performance A- gt D    259417 us DynamicCast performance A- gt C    256203 us DynamicCast performance A- gt B    261202 us DynamicCast performance A- gt A    193535 us

User · Answer

include  lt iostream h gt   include lt typeinfo h gt   template lt class T gt  void fun T a      if typeid T     typeid int              Do something      cout lt  lt  int         else if typeid T     typeid float              Do Something else      cout lt  lt  float          void main            fun 23         fun 90 67f

User · Answer

Try using   if NewType  v   dynamic cast lt NewType  gt  old           old was safely casted to NewType    v- gt doSomething        This requires your compiler to have rtti support enabled   EDIT  I ve had some good comments on this answer   Every time you need to use a dynamic cast  or instanceof  you d better ask yourself whether it s a necessary thing  It s generally a sign of poor design    Typical workarounds is putting the special behaviour for the class you are checking for into a virtual function on the base class or perhaps introducing something like a visitor where you can introduce specific behaviour for subclasses without changing the interface  except for adding the visitor acceptance interface of course    As pointed out dynamic cast doesn t come for free  A simple and consistently performing hack that handles most  but not all cases  is basically adding an enum representing all the possible types your class can have and check whether you got the right one    if old- gt getType      BOX       Box  box   static cast lt Box  gt  old         Do something box specific     This is not good oo design  but it can be a workaround and its cost is more or less only a virtual function call  It also works regardless of RTTI is enabled or not   Note that this approach doesn t support multiple levels of inheritance so if you re not careful you might end with code looking like this      Here we have a SpecialBox class that inherits Box  since it has its own type    we must check for both BOX or SPECIAL BOX if old- gt getType      BOX    old- gt getType      SPECIAL BOX       Box  box   static cast lt Box  gt  old         Do something box specific

User · Answer

Instanceof implementation without dynamic cast  I think this question is still relevant today  Using the C  11 standard you are now able to implement a instanceof function without using dynamic cast like this   if  dynamic cast lt B  gt  aPtr     nullptr         aPtr is instance of B   else        aPtr is NOT instance of B     But you re still reliant on RTTI support  So here is my solution for this problem depending on some Macros and Metaprogramming Magic  The only drawback imho is that this approach does not work for multiple inheritance   InstanceOfMacros h   include  lt set gt   include  lt tuple gt   include  lt typeindex gt    define  EMPTY BASE TYPE DECL   using BaseTypes   std  tuple lt  gt    define  BASE TYPE DECL Class  BaseClass      using BaseTypes   decltype std  tuple cat std  tuple lt BaseClass gt     Class  BaseTypes       define  INSTANCE OF DECL BODY Class                                      static const std  set lt std  type index gt  baseTypeContainer                virtual bool instanceOfHelper const std  type index  amp  tidx                if  std  type index typeid ThisType       tidx  return true             if  std  tuple size lt BaseTypes gt   value    0  return false                return baseTypeContainer find  tidx     baseTypeContainer end                                                                                 template  lt typename    T gt                                                 static std  set lt std  type index gt  getTypeIndexes std  tuple lt T    gt           return std  set lt std  type index gt  std  type index typeid T                 define INSTANCE OF SUB DECL Class  BaseClass     protected                                         using ThisType   Class                            BASE TYPE DECL Class  BaseClass                  INSTANCE OF DECL BODY Class    define INSTANCE OF BASE DECL Class                                                        protected                                                                                  using ThisType   Class                                                                     EMPTY BASE TYPE DECL                                                                      INSTANCE OF DECL BODY Class                                                             public                                                                                     template  lt typename Of gt                                                                     typename std  enable if lt std  is base of lt Class  Of gt   value  bool gt   type instanceOf           return instanceOfHelper std  type index typeid Of                                           define INSTANCE OF IMPL Class      const std  set lt std  type index gt  Class  baseTypeContainer   Class  getTypeIndexes Class  BaseTypes       Demo  You can then use this stuff  with caution  as follows   DemoClassHierarchy hpp    include  InstanceOfMacros h   struct A     virtual  A        INSTANCE OF BASE DECL A     INSTANCE OF IMPL A   struct B   public A     virtual  B        INSTANCE OF SUB DECL B  A     INSTANCE OF IMPL B   struct C   public A     virtual  C        INSTANCE OF SUB DECL C  A     INSTANCE OF IMPL C   struct D   public C     virtual  D        INSTANCE OF SUB DECL D  C     INSTANCE OF IMPL D    The following code presents a small demo to verify rudimentary the correct behavior   InstanceOfDemo cpp   include  lt iostream gt   include  lt memory gt   include  DemoClassHierarchy hpp   int main       A  a2aPtr   new A    A  a2bPtr   new B    std  shared ptr lt A gt  a2cPtr new C     C  c2dPtr   new D    std  unique ptr lt A gt  a2dPtr new D      std  cout  lt  lt   a2aPtr- gt instanceOf lt A gt     expected 1  value    lt  lt  a2aPtr- gt instanceOf lt A gt     lt  lt  std  endl    std  cout  lt  lt   a2aPtr- gt instanceOf lt B gt     expected 0  value    lt  lt  a2aPtr- gt instanceOf lt B gt     lt  lt  std  endl    std  cout  lt  lt   a2aPtr- gt instanceOf lt C gt     expected 0  value    lt  lt  a2aPtr- gt instanceOf lt C gt     lt  lt  std  endl    std  cout  lt  lt   a2aPtr- gt instanceOf lt D gt     expected 0  value    lt  lt  a2aPtr- gt instanceOf lt D gt     lt  lt  std  endl    std  cout  lt  lt  std  endl    std  cout  lt  lt   a2bPtr- gt instanceOf lt A gt     expected 1  value    lt  lt  a2bPtr- gt instanceOf lt A gt     lt  lt  std  endl    std  cout  lt  lt   a2bPtr- gt instanceOf lt B gt     expected 1  value    lt  lt  a2bPtr- gt instanceOf lt B gt     lt  lt  std  endl    std  cout  lt  lt   a2bPtr- gt instanceOf lt C gt     expected 0  value    lt  lt  a2bPtr- gt instanceOf lt C gt     lt  lt  std  endl    std  cout  lt  lt   a2bPtr- gt instanceOf lt D gt     expected 0  value    lt  lt  a2bPtr- gt instanceOf lt D gt     lt  lt  std  endl    std  cout  lt  lt  std  endl    std  cout  lt  lt   a2cPtr- gt instanceOf lt A gt     expected 1  value    lt  lt  a2cPtr- gt instanceOf lt A gt     lt  lt  std  endl    std  cout  lt  lt   a2cPtr- gt instanceOf lt B gt     expected 0  value    lt  lt  a2cPtr- gt instanceOf lt B gt     lt  lt  std  endl    std  cout  lt  lt   a2cPtr- gt instanceOf lt C gt     expected 1  value    lt  lt  a2cPtr- gt instanceOf lt C gt     lt  lt  std  endl    std  cout  lt  lt   a2cPtr- gt instanceOf lt D gt     expected 0  value    lt  lt  a2cPtr- gt instanceOf lt D gt     lt  lt  std  endl    std  cout  lt  lt  std  endl    std  cout  lt  lt   c2dPtr- gt instanceOf lt A gt     expected 1  value    lt  lt  c2dPtr- gt instanceOf lt A gt     lt  lt  std  endl    std  cout  lt  lt   c2dPtr- gt instanceOf lt B gt     expected 0  value    lt  lt  c2dPtr- gt instanceOf lt B gt     lt  lt  std  endl    std  cout  lt  lt   c2dPtr- gt instanceOf lt C gt     expected 1  value    lt  lt  c2dPtr- gt instanceOf lt C gt     lt  lt  std  endl    std  cout  lt  lt   c2dPtr- gt instanceOf lt D gt     expected 1  value    lt  lt  c2dPtr- gt instanceOf lt D gt     lt  lt  std  endl    std  cout  lt  lt  std  endl    std  cout  lt  lt   a2dPtr- gt instanceOf lt A gt     expected 1  value    lt  lt  a2dPtr- gt instanceOf lt A gt     lt  lt  std  endl    std  cout  lt  lt   a2dPtr- gt instanceOf lt B gt     expected 0  value    lt  lt  a2dPtr- gt instanceOf lt B gt     lt  lt  std  endl    std  cout  lt  lt   a2dPtr- gt instanceOf lt C gt     expected 1  value    lt  lt  a2dPtr- gt instanceOf lt C gt     lt  lt  std  endl    std  cout  lt  lt   a2dPtr- gt instanceOf lt D gt     expected 1  value    lt  lt  a2dPtr- gt instanceOf lt D gt     lt  lt  std  endl     delete a2aPtr    delete a2bPtr    delete c2dPtr     return 0      Output   a2aPtr- gt instanceOf lt A gt     expected 1  value 1 a2aPtr- gt instanceOf lt B gt     expected 0  value 0 a2aPtr- gt instanceOf lt C gt     expected 0  value 0 a2aPtr- gt instanceOf lt D gt     expected 0  value 0  a2bPtr- gt instanceOf lt A gt     expected 1  value 1 a2bPtr- gt instanceOf lt B gt     expected 1  value 1 a2bPtr- gt instanceOf lt C gt     expected 0  value 0 a2bPtr- gt instanceOf lt D gt     expected 0  value 0  a2cPtr- gt instanceOf lt A gt     expected 1  value 1 a2cPtr- gt instanceOf lt B gt     expected 0  value 0 a2cPtr- gt instanceOf lt C gt     expected 1  value 1 a2cPtr- gt instanceOf lt D gt     expected 0  value 0  c2dPtr- gt instanceOf lt A gt     expected 1  value 1 c2dPtr- gt instanceOf lt B gt     expected 0  value 0 c2dPtr- gt instanceOf lt C gt     expected 1  value 1 c2dPtr- gt instanceOf lt D gt     expected 1  value 1  a2dPtr- gt instanceOf lt A gt     expected 1  value 1 a2dPtr- gt instanceOf lt B gt     expected 0  value 0 a2dPtr- gt instanceOf lt C gt     expected 1  value 1 a2dPtr- gt instanceOf lt D gt     expected 1  value 1   Performance  The most interesting question which now arises is  if this evil stuff is more efficient than the usage of dynamic cast  Therefore I ve written a very basic performance measurement app   InstanceOfPerformance cpp   include  lt chrono gt   include  lt iostream gt   include  lt string gt   include  DemoClassHierarchy hpp   template  lt typename Base  typename Derived  typename Duration gt  Duration instanceOfMeasurement unsigned  loopCycles      auto start   std  chrono  high resolution clock  now      volatile bool isInstanceOf   false    for  unsigned i   0  i  lt   loopCycles    i        Base  ptr   new Derived      isInstanceOf   ptr- gt template instanceOf lt Derived gt         delete ptr        auto end   std  chrono  high resolution clock  now      return std  chrono  duration cast lt Duration gt  end - start      template  lt typename Base  typename Derived  typename Duration gt  Duration dynamicCastMeasurement unsigned  loopCycles      auto start   std  chrono  high resolution clock  now      volatile bool isInstanceOf   false    for  unsigned i   0  i  lt   loopCycles    i        Base  ptr   new Derived      isInstanceOf   dynamic cast lt Derived   gt  ptr     nullptr      delete ptr        auto end   std  chrono  high resolution clock  now      return std  chrono  duration cast lt Duration gt  end - start      int main       unsigned testCycles   10000000    std  string unit     us     using DType   std  chrono  microseconds     std  cout  lt  lt   InstanceOf performance A- gt D        lt  lt  instanceOfMeasurement lt A  D  DType gt  testCycles  count    lt  lt  unit              lt  lt  std  endl    std  cout  lt  lt   InstanceOf performance A- gt C        lt  lt  instanceOfMeasurement lt A  C  DType gt  testCycles  count    lt  lt  unit              lt  lt  std  endl    std  cout  lt  lt   InstanceOf performance A- gt B        lt  lt  instanceOfMeasurement lt A  B  DType gt  testCycles  count    lt  lt  unit              lt  lt  std  endl    std  cout  lt  lt   InstanceOf performance A- gt A        lt  lt  instanceOfMeasurement lt A  A  DType gt  testCycles  count    lt  lt  unit              lt  lt    n               lt  lt  std  endl    std  cout  lt  lt   DynamicCast performance A- gt D       lt  lt  dynamicCastMeasurement lt A  D  DType gt  testCycles  count    lt  lt  unit              lt  lt  std  endl    std  cout  lt  lt   DynamicCast performance A- gt C       lt  lt  dynamicCastMeasurement lt A  C  DType gt  testCycles  count    lt  lt  unit              lt  lt  std  endl    std  cout  lt  lt   DynamicCast performance A- gt B       lt  lt  dynamicCastMeasurement lt A  B  DType gt  testCycles  count    lt  lt  unit              lt  lt  std  endl    std  cout  lt  lt   DynamicCast performance A- gt A       lt  lt  dynamicCastMeasurement lt A  A  DType gt  testCycles  count    lt  lt  unit              lt  lt    n               lt  lt  std  endl    return 0      The results vary and are essentially based on the degree of compiler optimization  Compiling the performance measurement program using g   -std c  11 -O0 -o instanceof-performance InstanceOfPerformance cpp the output on my local machine was   InstanceOf performance A- gt D     699638 us InstanceOf performance A- gt C     642157 us InstanceOf performance A- gt B     671399 us InstanceOf performance A- gt A     626193 us  DynamicCast performance A- gt D    754937 us DynamicCast performance A- gt C    706766 us DynamicCast performance A- gt B    751353 us DynamicCast performance A- gt A    676853 us   Mhm  this result was very sobering  because the timings demonstrates that the new approach is not much faster compared to the dynamic cast approach  It is even less efficient for the special test case which tests if a pointer of A is an instance ofA  BUT the tide turns by tuning our binary using compiler otpimization  The respective compiler command is g   -std c  11 -O3 -o instanceof-performance InstanceOfPerformance cpp  The result on my local machine was amazing   InstanceOf performance A- gt D     3035 us InstanceOf performance A- gt C     5030 us InstanceOf performance A- gt B     5250 us InstanceOf performance A- gt A     3021 us  DynamicCast performance A- gt D    666903 us DynamicCast performance A- gt C    698567 us DynamicCast performance A- gt B    727368 us DynamicCast performance A- gt A    3098 us   If you are not reliant on multiple inheritance  are no opponent of good old C macros  RTTI and template metaprogramming and are not too lazy to add some small instructions to the classes of your class hierarchy  then this approach can boost your application a little bit with respect to its performance  if you often end up with checking the instance of a pointer  But use it with caution  There is no warranty for the correctness of this approach   Note  All demos were compiled using clang  Apple LLVM version 9 0 0  clang-900 0 39 2   under macOS Sierra on a MacBook Pro Mid 2012   Edit  I ve also tested the performance on a Linux machine using gcc  Ubuntu 5 4 0-6ubuntu1 16 04 9  5 4 0 20160609  On this platform the perfomance benefit was not so significant as on macOs with clang   Output  without compiler optimization    InstanceOf performance A- gt D     390768 us InstanceOf performance A- gt C     333994 us InstanceOf performance A- gt B     334596 us InstanceOf performance A- gt A     300959 us  DynamicCast performance A- gt D    331942 us DynamicCast performance A- gt C    303715 us DynamicCast performance A- gt B    400262 us DynamicCast performance A- gt A    324942 us   Output  with compiler optimization    InstanceOf performance A- gt D     209501 us InstanceOf performance A- gt C     208727 us InstanceOf performance A- gt B     207815 us InstanceOf performance A- gt A     197953 us  DynamicCast performance A- gt D    259417 us DynamicCast performance A- gt C    256203 us DynamicCast performance A- gt B    261202 us DynamicCast performance A- gt A    193535 us

User · Answer

Depending on what you want to do you could do this   template lt typename Base  typename T gt  inline bool instanceof const T         return std  is base of lt Base  T gt   value      Use   if  instanceof lt BaseClass gt  ptr             However  this purely operates on the types as known by the compiler   Edit   This code should work for polymorphic pointers   template lt typename Base  typename T gt  inline bool instanceof const T  ptr        return dynamic cast lt const Base  gt  ptr     nullptr      Example  http   cpp sh 6qir

User · Answer

Try using   if NewType  v   dynamic cast lt NewType  gt  old           old was safely casted to NewType    v- gt doSomething        This requires your compiler to have rtti support enabled   EDIT  I ve had some good comments on this answer   Every time you need to use a dynamic cast  or instanceof  you d better ask yourself whether it s a necessary thing  It s generally a sign of poor design    Typical workarounds is putting the special behaviour for the class you are checking for into a virtual function on the base class or perhaps introducing something like a visitor where you can introduce specific behaviour for subclasses without changing the interface  except for adding the visitor acceptance interface of course    As pointed out dynamic cast doesn t come for free  A simple and consistently performing hack that handles most  but not all cases  is basically adding an enum representing all the possible types your class can have and check whether you got the right one    if old- gt getType      BOX       Box  box   static cast lt Box  gt  old         Do something box specific     This is not good oo design  but it can be a workaround and its cost is more or less only a virtual function call  It also works regardless of RTTI is enabled or not   Note that this approach doesn t support multiple levels of inheritance so if you re not careful you might end with code looking like this      Here we have a SpecialBox class that inherits Box  since it has its own type    we must check for both BOX or SPECIAL BOX if old- gt getType      BOX    old- gt getType      SPECIAL BOX       Box  box   static cast lt Box  gt  old         Do something box specific

User · Answer

Try using   if NewType  v   dynamic cast lt NewType  gt  old           old was safely casted to NewType    v- gt doSomething        This requires your compiler to have rtti support enabled   EDIT  I ve had some good comments on this answer   Every time you need to use a dynamic cast  or instanceof  you d better ask yourself whether it s a necessary thing  It s generally a sign of poor design    Typical workarounds is putting the special behaviour for the class you are checking for into a virtual function on the base class or perhaps introducing something like a visitor where you can introduce specific behaviour for subclasses without changing the interface  except for adding the visitor acceptance interface of course    As pointed out dynamic cast doesn t come for free  A simple and consistently performing hack that handles most  but not all cases  is basically adding an enum representing all the possible types your class can have and check whether you got the right one    if old- gt getType      BOX       Box  box   static cast lt Box  gt  old         Do something box specific     This is not good oo design  but it can be a workaround and its cost is more or less only a virtual function call  It also works regardless of RTTI is enabled or not   Note that this approach doesn t support multiple levels of inheritance so if you re not careful you might end with code looking like this      Here we have a SpecialBox class that inherits Box  since it has its own type    we must check for both BOX or SPECIAL BOX if old- gt getType      BOX    old- gt getType      SPECIAL BOX       Box  box   static cast lt Box  gt  old         Do something box specific

User · Answer

Try using   if NewType  v   dynamic cast lt NewType  gt  old           old was safely casted to NewType    v- gt doSomething        This requires your compiler to have rtti support enabled   EDIT  I ve had some good comments on this answer   Every time you need to use a dynamic cast  or instanceof  you d better ask yourself whether it s a necessary thing  It s generally a sign of poor design    Typical workarounds is putting the special behaviour for the class you are checking for into a virtual function on the base class or perhaps introducing something like a visitor where you can introduce specific behaviour for subclasses without changing the interface  except for adding the visitor acceptance interface of course    As pointed out dynamic cast doesn t come for free  A simple and consistently performing hack that handles most  but not all cases  is basically adding an enum representing all the possible types your class can have and check whether you got the right one    if old- gt getType      BOX       Box  box   static cast lt Box  gt  old         Do something box specific     This is not good oo design  but it can be a workaround and its cost is more or less only a virtual function call  It also works regardless of RTTI is enabled or not   Note that this approach doesn t support multiple levels of inheritance so if you re not careful you might end with code looking like this      Here we have a SpecialBox class that inherits Box  since it has its own type    we must check for both BOX or SPECIAL BOX if old- gt getType      BOX    old- gt getType      SPECIAL BOX       Box  box   static cast lt Box  gt  old         Do something box specific

User · Answer

Depending on what you want to do you could do this   template lt typename Base  typename T gt  inline bool instanceof const T         return std  is base of lt Base  T gt   value      Use   if  instanceof lt BaseClass gt  ptr             However  this purely operates on the types as known by the compiler   Edit   This code should work for polymorphic pointers   template lt typename Base  typename T gt  inline bool instanceof const T  ptr        return dynamic cast lt const Base  gt  ptr     nullptr      Example  http   cpp sh 6qir

User · Answer

dynamic cast is known to be inefficient  It traverses up the inheritance hierarchy  and it is the only solution if you have multiple levels of inheritance  and need to check if an object is an instance of any one of the types in its type hierarchy   But if a more limited form of instanceof that only checks if an object is exactly the type you specify  suffices for your needs  the function below would be a lot more efficient   template lt typename T  typename K gt  inline bool isType const K  amp k        return typeid T  hash code      typeid k  hash code        Here s an example of how you d invoke the function above   DerivedA k  Base  p    amp k   cout  lt  lt  boolalpha  lt  lt  isType lt DerivedA gt   p   lt  lt  endl      true cout  lt  lt  boolalpha  lt  lt  isType lt DerivedB gt   p   lt  lt  endl      false   You d specify template type A  as the type you re checking for   and pass in the object you want to test as the argument  from which template type K would be inferred

[java] C++ equivalent of java's instanceof

Examples related to java

Examples related to c++

Examples related to oop

Examples related to instanceof