In C++ check if two instances of a base class are infact of the same subclass

Question

The below code explains the problem. Fill in same_sub_class to detect if the two pointers to virtual base class A are in fact the same concrete class.

struct A {
    ...
}:

struct B : public A {
    ...
}:

struct C : public A {
    ...
}


bool same_sub_class(A * a1, A * a2){
    // Fill this in to return true if a1 and a2 are
    // of the same concrete class
}

EDIT:

As I look at my application I need something slightly different from the above. I need to be able to group instances by their type_id.

FYI. I have a mini symbolic algerbra system so to do manipulations it is important to know the class type sometimes for sorting, and rearranging expressions.

So given a vector of pointers to instance how to group them by their type_id. I'd either need to be able to hash the type_id or generate a unique integer for every class.

Answer 1

If you can use RTTI,

typeid(*a1) == typeid(*a2)

I think you also need to

#include <typeinfo>

And you must have a virtual function in your classes so that the vtable exists--a destructor should do fine.

UPDATE:

I'm not sure I completely understand what your requirements are for grouping (Do you need some kind of deterministic ordering? What should happen with sub-subclasses?), but you could try using the value returned from the typeid operator to either:

• Hash the string returned from typeid(*ptr).name()
• Use typeid(*a1).before(typeid(*a2)) as an ordering criterion. This doesn't have any determinism between runs, though.

Generally when considering RTTI, it is a good idea to see if any of this can be accomplished better using well-crafted virtual functions (double dispatch, for example). I really can't say if there is a good alternative in your case though, since I don't understand the specifics.

Answer 2

typeid(*a1) == typeid(*a2)

Note the dereference, it is important.

Answer 3

You could make your own type Identifier:

struct A{
...
protected:
 enum TypeTag{B_TYPE, C_TYPE};
 TypeTag typeTag;
};

And then in constructors of subclasses:

B::B()
: typeTag(TypeTag::B_TYPE)
{
...
}

C::C()
: typeTag(TypeTag::C_TYPE)
{
...
}

Answer 4

Actually there are a fairly simple answers to this. But it involves posing the questions a bit clearer.

(A) If I want to store typeinfo objects in an unordered_set what do I need to do?

typeinfo support the == and the name() method. The name can be used to generate a hash and == for equality

(B) If I want to store typeinfo objects in an ordered_set ( std::set ) what do I need to do?

typeinfo supports the == and the before() method. With bit of wrapping of these two methods I can implement an interface for a Compare function that gives me strict weak ordering.

Answer 5

There is a feature in C++ called RTTI (runtime type information) which allows you to do such things.

One other possibility to have runtime type checking is to create a base class from which all your classes derive from. In your base class include a field which contains its type as a string or a number.

Answer 6

One trick that may or may not work with RTTI, depending on your compiler, is the following

const type_info &a1_type_info= typeid(*a1);
const type_info &a2_type_info= typeid(*a2);

return &a1_type_info==&a2_type_info || a1_type_info==a2_type_info;

If your compiler creates type_info instances by value, this will fail the first test but succeed on the second test. If your compiler caches the instances, the first test will succeed (if it's the same type) and be much faster since it's just a pointer compare. If your compiler returns different instances because a1 and a2 came from different shared libraries, it should still work.