How do I check if an object s type is a particular subclass in C

Question

I was thinking along the lines of using typeid   but I don t know how to ask if that type is a subclass of another class  which  by the way  is abstract

User · Answer

I don t know if I understand your problem correctly  so let me restate it in my own words     Problem  Given classes B and D  determine if D is a subclass of B  or vice-versa    Solution  Use some template magic  Okay  seriously you need to take a look at LOKI  an excellent template meta-programming library produced by the fabled C   author Andrei Alexandrescu   More specifically  download LOKI and include header TypeManip h from it in your source code then use the SuperSubclass class template as follows   if SuperSubClass lt B D gt   value            According to documentation  SuperSubClass lt B D gt   value will be true if B is a public base of D  or if B and D are aliases of the same type   i e  either D is a subclass of B or D is the same as B   I hope this helps   edit   Please note the evaluation of SuperSubClass lt B D gt   value happens at compile time unlike some methods which use dynamic cast  hence there is no penalty for using this system at runtime

User · Answer

You can do it with dynamic cast  at least for polymorphic types    Actually  on second thought--you can t tell if it is SPECIFICALLY a particular type with dynamic cast--but you can tell if it is that type or any subclass thereof   template  lt class DstType  class SrcType gt  bool IsType const SrcType  src      return dynamic cast lt const DstType  gt  src     nullptr

User · Answer

I don t know if I understand your problem correctly  so let me restate it in my own words     Problem  Given classes B and D  determine if D is a subclass of B  or vice-versa    Solution  Use some template magic  Okay  seriously you need to take a look at LOKI  an excellent template meta-programming library produced by the fabled C   author Andrei Alexandrescu   More specifically  download LOKI and include header TypeManip h from it in your source code then use the SuperSubclass class template as follows   if SuperSubClass lt B D gt   value            According to documentation  SuperSubClass lt B D gt   value will be true if B is a public base of D  or if B and D are aliases of the same type   i e  either D is a subclass of B or D is the same as B   I hope this helps   edit   Please note the evaluation of SuperSubClass lt B D gt   value happens at compile time unlike some methods which use dynamic cast  hence there is no penalty for using this system at runtime

User · Answer

In c  you can simply say   if  myObj is Car

User · Answer

You really shouldn t   If your program needs to know what class an object is  that usually indicates a design flaw   See if you can get the behavior you want using virtual functions   Also  more information about what you are trying to do would help   I am assuming you have a situation like this   class Base  class A   public Base        class B   public Base         void foo Base  p      if    p is A        do X      else    do Y        If this is what you have  then try to do something like this   class Base     virtual void bar     0      class A   public Base     void bar       do X         class B   public Base     void bar       do Y         void foo Base  p      p- gt bar        Edit  Since the debate about this answer still goes on after so many years  I thought I should throw in some references  If you have a pointer or reference to a base class  and your code needs to know the derived class of the object  then it violates Liskov substitution principle  Uncle Bob calls this an  anathema to Object Oriented Design

User · Answer

You can only do it at compile time using templates  unless you use RTTI    It lets you use the typeid function which will yield a pointer to a type info structure which contains information about the type   Read up on it at Wikipedia

User · Answer

dynamic cast can determine if the type contains the target type anywhere in the inheritance hierarchy  yes  it s a little-known feature that if B inherits from A and C  it can turn an A  directly into a C    typeid   can determine the exact type of the object  However  these should both be used extremely sparingly  As has been mentioned already  you should always be avoiding dynamic type identification  because it indicates a design flaw   also  if you know the object is for sure of the target type  you can do a downcast with a static cast  Boost offers a polymorphic downcast that will do a downcast with dynamic cast and assert in debug mode  and in release mode it will just use a static cast

User · Answer

In c  you can simply say   if  myObj is Car

User · Answer

In c  you can simply say   if  myObj is Car

User · Answer

The code below demonstrates 3 different ways of doing it    virtual function typeid dynamic cast    include  lt iostream gt   include  lt typeinfo gt   include  lt typeindex gt   enum class Type  Base  A  B    class Base   public      virtual  Base     default      virtual Type type   const           return Type  Base            class A   public Base       Type type   const override           return Type  A            class B   public Base       Type type   const override           return Type  B            int main         const char  typemsg      A a      B b      Base  base    amp a                    amp b                           Base  amp bbb    base          below you can replace    base    with   amp bbb    and get the same results         USING virtual function                                      classes need to be in your control     switch base- gt type          case Type  A          typemsg    type A           break      case Type  B          typemsg    type B           break      default          typemsg    unknown             std  cout  lt  lt  typemsg  lt  lt  std  endl          USING typeid                                      needs RTTI  under gcc  avoid -fno-rtti     std  type index ti typeid  base        if  ti    std  type index typeid A              typemsg    type A         else if  ti    std  type index typeid B              typemsg    type B         else           typemsg    unknown             std  cout  lt  lt  typemsg  lt  lt  std  endl          USING dynamic cast                                      needs RTTI  under gcc  avoid -fno-rtti     if  dynamic cast lt   const   A  gt  base             typemsg    type A         else if  dynamic cast lt   const   B  gt  base             typemsg    type B         else           typemsg    unknown             std  cout  lt  lt  typemsg  lt  lt  std  endl      The program above prints this   type A type A type A

User · Answer

dynamic cast can determine if the type contains the target type anywhere in the inheritance hierarchy  yes  it s a little-known feature that if B inherits from A and C  it can turn an A  directly into a C    typeid   can determine the exact type of the object  However  these should both be used extremely sparingly  As has been mentioned already  you should always be avoiding dynamic type identification  because it indicates a design flaw   also  if you know the object is for sure of the target type  you can do a downcast with a static cast  Boost offers a polymorphic downcast that will do a downcast with dynamic cast and assert in debug mode  and in release mode it will just use a static cast

User · Answer

You can only do it at compile time using templates  unless you use RTTI    It lets you use the typeid function which will yield a pointer to a type info structure which contains information about the type   Read up on it at Wikipedia

User · Answer

You can do it with dynamic cast  at least for polymorphic types    Actually  on second thought--you can t tell if it is SPECIFICALLY a particular type with dynamic cast--but you can tell if it is that type or any subclass thereof   template  lt class DstType  class SrcType gt  bool IsType const SrcType  src      return dynamic cast lt const DstType  gt  src     nullptr

User · Answer

You really shouldn t   If your program needs to know what class an object is  that usually indicates a design flaw   See if you can get the behavior you want using virtual functions   Also  more information about what you are trying to do would help   I am assuming you have a situation like this   class Base  class A   public Base        class B   public Base         void foo Base  p      if    p is A        do X      else    do Y        If this is what you have  then try to do something like this   class Base     virtual void bar     0      class A   public Base     void bar       do X         class B   public Base     void bar       do Y         void foo Base  p      p- gt bar        Edit  Since the debate about this answer still goes on after so many years  I thought I should throw in some references  If you have a pointer or reference to a base class  and your code needs to know the derived class of the object  then it violates Liskov substitution principle  Uncle Bob calls this an  anathema to Object Oriented Design

User · Answer

include  lt stdio h gt   include  lt iostream h gt   class Base     public  virtual  Base         template lt typename T gt    bool isA         return  dynamic cast lt T  gt  this     NULL           class D1  public Base     class D2  public Base     class D22  public D2      int main int argc char  argv         D1    d1    new D1      D2    d2    new D2      D22   d22   new D22       Base   x   d22     if  x- gt isA lt D22 gt              std  cout  lt  lt   IS A D22   lt  lt  std  endl        if  x- gt isA lt D2 gt              std  cout  lt  lt   IS A D2   lt  lt  std  endl        if  x- gt isA lt D1 gt              std  cout  lt  lt   IS A D1   lt  lt  std  endl        if x- gt isA lt Base gt              std  cout  lt  lt   IS A Base   lt  lt  std  endl          Result   IS A D22 IS A D2 IS A Base

User · Answer

include  lt stdio h gt   include  lt iostream h gt   class Base     public  virtual  Base         template lt typename T gt    bool isA         return  dynamic cast lt T  gt  this     NULL           class D1  public Base     class D2  public Base     class D22  public D2      int main int argc char  argv         D1    d1    new D1      D2    d2    new D2      D22   d22   new D22       Base   x   d22     if  x- gt isA lt D22 gt              std  cout  lt  lt   IS A D22   lt  lt  std  endl        if  x- gt isA lt D2 gt              std  cout  lt  lt   IS A D2   lt  lt  std  endl        if  x- gt isA lt D1 gt              std  cout  lt  lt   IS A D1   lt  lt  std  endl        if x- gt isA lt Base gt              std  cout  lt  lt   IS A Base   lt  lt  std  endl          Result   IS A D22 IS A D2 IS A Base

User · Answer

You can do it with dynamic cast  at least for polymorphic types    Actually  on second thought--you can t tell if it is SPECIFICALLY a particular type with dynamic cast--but you can tell if it is that type or any subclass thereof   template  lt class DstType  class SrcType gt  bool IsType const SrcType  src      return dynamic cast lt const DstType  gt  src     nullptr

User · Answer

I was thinking along the lines of using typeid        Well  yes  it could be done by comparing  typeid   name    If we take the already described situation  where   class Base  class A   public Base        class B   public Base         void foo Base  p      if    p is A        do X      else    do Y        A possible implementation of foo Base  p  would be    include  lt typeinfo gt   void foo Base  p        if typeid  p     typeid A                    the pointer is pointing to the derived class A             else if  typeid  p  name      typeid B  name                      the pointer is pointing to the derived class B

User · Answer

You can do it with templates  or SFINAE  Substitution Failure Is Not An Error    Example   include  lt iostream gt   class base   public      virtual  base     default      template  lt      class type      class   decltype          static cast lt base  gt  static cast lt type  gt  0          gt  bool check type        return true     bool check            return false     class child   public base   public      virtual  child     default      class grandchild   public child      int main         std  cout  lt  lt  std  boolalpha       std  cout  lt  lt   quot base         quot   lt  lt  check base           lt  lt    n       std  cout  lt  lt   quot child        quot   lt  lt  check child          lt  lt    n       std  cout  lt  lt   quot grandchild   quot   lt  lt  check grandchild     lt  lt    n       std  cout  lt  lt   quot int          quot   lt  lt  check int            lt  lt    n        std  cout  lt  lt  std  flush     Output  base        true child       true grandchild  true int         false

User · Answer

dynamic cast can determine if the type contains the target type anywhere in the inheritance hierarchy  yes  it s a little-known feature that if B inherits from A and C  it can turn an A  directly into a C    typeid   can determine the exact type of the object  However  these should both be used extremely sparingly  As has been mentioned already  you should always be avoiding dynamic type identification  because it indicates a design flaw   also  if you know the object is for sure of the target type  you can do a downcast with a static cast  Boost offers a polymorphic downcast that will do a downcast with dynamic cast and assert in debug mode  and in release mode it will just use a static cast

User · Answer

I don t know if I understand your problem correctly  so let me restate it in my own words     Problem  Given classes B and D  determine if D is a subclass of B  or vice-versa    Solution  Use some template magic  Okay  seriously you need to take a look at LOKI  an excellent template meta-programming library produced by the fabled C   author Andrei Alexandrescu   More specifically  download LOKI and include header TypeManip h from it in your source code then use the SuperSubclass class template as follows   if SuperSubClass lt B D gt   value            According to documentation  SuperSubClass lt B D gt   value will be true if B is a public base of D  or if B and D are aliases of the same type   i e  either D is a subclass of B or D is the same as B   I hope this helps   edit   Please note the evaluation of SuperSubClass lt B D gt   value happens at compile time unlike some methods which use dynamic cast  hence there is no penalty for using this system at runtime

User · Answer

You really shouldn t   If your program needs to know what class an object is  that usually indicates a design flaw   See if you can get the behavior you want using virtual functions   Also  more information about what you are trying to do would help   I am assuming you have a situation like this   class Base  class A   public Base        class B   public Base         void foo Base  p      if    p is A        do X      else    do Y        If this is what you have  then try to do something like this   class Base     virtual void bar     0      class A   public Base     void bar       do X         class B   public Base     void bar       do Y         void foo Base  p      p- gt bar        Edit  Since the debate about this answer still goes on after so many years  I thought I should throw in some references  If you have a pointer or reference to a base class  and your code needs to know the derived class of the object  then it violates Liskov substitution principle  Uncle Bob calls this an  anathema to Object Oriented Design

User · Answer

You can only do it at compile time using templates  unless you use RTTI    It lets you use the typeid function which will yield a pointer to a type info structure which contains information about the type   Read up on it at Wikipedia

User · Answer

nbsp   class Base     public  virtual  Base          class D1  public Base      class D2  public Base      int main int argc char  argv         D1   d1    D2   d2     Base   x    argc  gt  2   amp d1  amp d2     if  dynamic cast lt D2  gt  x     nullptr          std  cout  lt  lt   NOT A D2   lt  lt  std  endl        if  dynamic cast lt D1  gt  x     nullptr          std  cout  lt  lt   NOT A D1   lt  lt  std  endl

User · Answer

You can do it with dynamic cast  at least for polymorphic types    Actually  on second thought--you can t tell if it is SPECIFICALLY a particular type with dynamic cast--but you can tell if it is that type or any subclass thereof   template  lt class DstType  class SrcType gt  bool IsType const SrcType  src      return dynamic cast lt const DstType  gt  src     nullptr

User · Answer

dynamic cast can determine if the type contains the target type anywhere in the inheritance hierarchy  yes  it s a little-known feature that if B inherits from A and C  it can turn an A  directly into a C    typeid   can determine the exact type of the object  However  these should both be used extremely sparingly  As has been mentioned already  you should always be avoiding dynamic type identification  because it indicates a design flaw   also  if you know the object is for sure of the target type  you can do a downcast with a static cast  Boost offers a polymorphic downcast that will do a downcast with dynamic cast and assert in debug mode  and in release mode it will just use a static cast

User · Answer

In c  you can simply say   if  myObj is Car

User · Answer

You can only do it at compile time using templates  unless you use RTTI    It lets you use the typeid function which will yield a pointer to a type info structure which contains information about the type   Read up on it at Wikipedia

User · Answer

I don t know if I understand your problem correctly  so let me restate it in my own words     Problem  Given classes B and D  determine if D is a subclass of B  or vice-versa    Solution  Use some template magic  Okay  seriously you need to take a look at LOKI  an excellent template meta-programming library produced by the fabled C   author Andrei Alexandrescu   More specifically  download LOKI and include header TypeManip h from it in your source code then use the SuperSubclass class template as follows   if SuperSubClass lt B D gt   value            According to documentation  SuperSubClass lt B D gt   value will be true if B is a public base of D  or if B and D are aliases of the same type   i e  either D is a subclass of B or D is the same as B   I hope this helps   edit   Please note the evaluation of SuperSubClass lt B D gt   value happens at compile time unlike some methods which use dynamic cast  hence there is no penalty for using this system at runtime

User · Answer

nbsp   class Base     public  virtual  Base          class D1  public Base      class D2  public Base      int main int argc char  argv         D1   d1    D2   d2     Base   x    argc  gt  2   amp d1  amp d2     if  dynamic cast lt D2  gt  x     nullptr          std  cout  lt  lt   NOT A D2   lt  lt  std  endl        if  dynamic cast lt D1  gt  x     nullptr          std  cout  lt  lt   NOT A D1   lt  lt  std  endl

User · Answer

You can do it with templates  or SFINAE  Substitution Failure Is Not An Error    Example   include  lt iostream gt   class base   public      virtual  base     default      template  lt      class type      class   decltype          static cast lt base  gt  static cast lt type  gt  0          gt  bool check type        return true     bool check            return false     class child   public base   public      virtual  child     default      class grandchild   public child      int main         std  cout  lt  lt  std  boolalpha       std  cout  lt  lt   quot base         quot   lt  lt  check base           lt  lt    n       std  cout  lt  lt   quot child        quot   lt  lt  check child          lt  lt    n       std  cout  lt  lt   quot grandchild   quot   lt  lt  check grandchild     lt  lt    n       std  cout  lt  lt   quot int          quot   lt  lt  check int            lt  lt    n        std  cout  lt  lt  std  flush     Output  base        true child       true grandchild  true int         false

User · Answer

nbsp   class Base     public  virtual  Base          class D1  public Base      class D2  public Base      int main int argc char  argv         D1   d1    D2   d2     Base   x    argc  gt  2   amp d1  amp d2     if  dynamic cast lt D2  gt  x     nullptr          std  cout  lt  lt   NOT A D2   lt  lt  std  endl        if  dynamic cast lt D1  gt  x     nullptr          std  cout  lt  lt   NOT A D1   lt  lt  std  endl

User · Answer

I disagree that you should never want to check an object s type in C     If you can avoid it  I agree that you should   Saying you should NEVER do this under any circumstance is going too far though   You can do this in a great many languages  and it can make your life a lot easier   Howard Pinsley  for instance  showed us how in his post on C      I do a lot of work with the Qt Framework   In general  I model what I do after the way they do things  at least when working in their framework    The QObject class is the base class of all Qt objects  That class has the functions isWidgetType   and isWindowType   as a quick subclass check  So why not be able to check your own derived classes  which is comparable in it s nature   Here is a QObject spin off of some of these other posts   class MyQObject   public QObject   public      MyQObject  QObject  parent   0     QObject  parent          MyQObject          static bool isThisType  const QObject  qObj         return   dynamic cast lt const MyQObject  gt  qObj     NULL           And then when you are passing around a pointer to a QObject  you can check if it points to your derived class by calling the static member function   if  MyQObject  isThisType  qObjPtr     qDebug    lt  lt   This is a MyQObject

User · Answer

nbsp   class Base     public  virtual  Base          class D1  public Base      class D2  public Base      int main int argc char  argv         D1   d1    D2   d2     Base   x    argc  gt  2   amp d1  amp d2     if  dynamic cast lt D2  gt  x     nullptr          std  cout  lt  lt   NOT A D2   lt  lt  std  endl        if  dynamic cast lt D1  gt  x     nullptr          std  cout  lt  lt   NOT A D1   lt  lt  std  endl

User · Answer

You really shouldn t   If your program needs to know what class an object is  that usually indicates a design flaw   See if you can get the behavior you want using virtual functions   Also  more information about what you are trying to do would help   I am assuming you have a situation like this   class Base  class A   public Base        class B   public Base         void foo Base  p      if    p is A        do X      else    do Y        If this is what you have  then try to do something like this   class Base     virtual void bar     0      class A   public Base     void bar       do X         class B   public Base     void bar       do Y         void foo Base  p      p- gt bar        Edit  Since the debate about this answer still goes on after so many years  I thought I should throw in some references  If you have a pointer or reference to a base class  and your code needs to know the derived class of the object  then it violates Liskov substitution principle  Uncle Bob calls this an  anathema to Object Oriented Design

User · Answer

I was thinking along the lines of using typeid        Well  yes  it could be done by comparing  typeid   name    If we take the already described situation  where   class Base  class A   public Base        class B   public Base         void foo Base  p      if    p is A        do X      else    do Y        A possible implementation of foo Base  p  would be    include  lt typeinfo gt   void foo Base  p        if typeid  p     typeid A                    the pointer is pointing to the derived class A             else if  typeid  p  name      typeid B  name                      the pointer is pointing to the derived class B

User · Answer

The code below demonstrates 3 different ways of doing it    virtual function typeid dynamic cast    include  lt iostream gt   include  lt typeinfo gt   include  lt typeindex gt   enum class Type  Base  A  B    class Base   public      virtual  Base     default      virtual Type type   const           return Type  Base            class A   public Base       Type type   const override           return Type  A            class B   public Base       Type type   const override           return Type  B            int main         const char  typemsg      A a      B b      Base  base    amp a                    amp b                           Base  amp bbb    base          below you can replace    base    with   amp bbb    and get the same results         USING virtual function                                      classes need to be in your control     switch base- gt type          case Type  A          typemsg    type A           break      case Type  B          typemsg    type B           break      default          typemsg    unknown             std  cout  lt  lt  typemsg  lt  lt  std  endl          USING typeid                                      needs RTTI  under gcc  avoid -fno-rtti     std  type index ti typeid  base        if  ti    std  type index typeid A              typemsg    type A         else if  ti    std  type index typeid B              typemsg    type B         else           typemsg    unknown             std  cout  lt  lt  typemsg  lt  lt  std  endl          USING dynamic cast                                      needs RTTI  under gcc  avoid -fno-rtti     if  dynamic cast lt   const   A  gt  base             typemsg    type A         else if  dynamic cast lt   const   B  gt  base             typemsg    type B         else           typemsg    unknown             std  cout  lt  lt  typemsg  lt  lt  std  endl      The program above prints this   type A type A type A

User · Answer

I disagree that you should never want to check an object s type in C     If you can avoid it  I agree that you should   Saying you should NEVER do this under any circumstance is going too far though   You can do this in a great many languages  and it can make your life a lot easier   Howard Pinsley  for instance  showed us how in his post on C      I do a lot of work with the Qt Framework   In general  I model what I do after the way they do things  at least when working in their framework    The QObject class is the base class of all Qt objects  That class has the functions isWidgetType   and isWindowType   as a quick subclass check  So why not be able to check your own derived classes  which is comparable in it s nature   Here is a QObject spin off of some of these other posts   class MyQObject   public QObject   public      MyQObject  QObject  parent   0     QObject  parent          MyQObject          static bool isThisType  const QObject  qObj         return   dynamic cast lt const MyQObject  gt  qObj     NULL           And then when you are passing around a pointer to a QObject  you can check if it points to your derived class by calling the static member function   if  MyQObject  isThisType  qObjPtr     qDebug    lt  lt   This is a MyQObject

[c++] How do I check if an object's type is a particular subclass in C++?

Examples related to c++

Examples related to class

Examples related to subclass

Examples related to identification