What is C++11's equivalent of Java's instanceof

Question

I want to know what the modern C++11 equivalent of Java's instanceof. I have seen this SO post but it is quite old and was wondering if there's a more modern, better solution in C++11?

I was hoping there's a possibility of using a switch construct without having to resort to a manual enum class.

class A {

};

class B : public A {

}

class C : public A {

}

on_event(A& obj)
{
    switch (obj) {
       case A:
       case B:
       case C:
    }
}

My base class does not have any virtual methods or functions. I am representing an expression tree for a parser and the base class is just a polymorphic holder - like an ADT in Haskell/OCaml.

Answer 1

The same answer still applies, and has always been like this in C++:

if (C * p = dynamic_cast<C *>(&obj))
{
    // The type of obj is or is derived from C
}
else
{
    // obj is not a C
}

This construction requires A to be polymorphic, i.e. to have virtual member functions.

Also note that this behaviour is different from comparing typeid(obj) == typeid(C), since the latter tests for exact type identity, whereas the dynamic cast, as well as Java's instanceof, only test for the target type to be a base class of the type of the most-derived object.

Answer 2

In C++ plain old data (POD) has no runtime type information. The classes described all take exactly 1 byte, and have identical runtime representations in any compiler with the empty base class optimization.

As such what you want cannot be done.

Adding a virtual destructor to the base class adds in RTTI, and dynamic_cast support.

Adding an enum or int field to the base that gets initialized differently for each derived class also works.

Yet another option is to create a template function, and store a pointer to it, like so:

using my_type_id=void(*)();
template<class>void get_my_type_id_helper(){};
template<class T> my_type_id get_my_type_id(){return get_my_type_id_helper<T>;}

and then storing a my_type_id in A initialized appropriately. This is reinventing RTTI, and as you want more features you will approach C++ RTTI overhead.

In C++ you only pay for what you ask for: you can ask for classes without RTTI, which you did, and get it.

RTTI is Run Time Type Information. POD is plain old data, a C++03 term. Many classes are not POD: the easy way is to add a virtual destructor. C++11 has more fine grained standard layout and aggregate terms.

Technically RTTI and POD are not opposites of each other: there are classes with no RTTI that are not POD.

Note that MSVC has options to not generate RTTI and its aggressive Comdat folding can break the manual RTTI I did above, in both cases in violation of the standard.

Answer 3

Maybe you are interested in the answer I've posted inside your mentioned old SO post.

https://stackoverflow.com/a/49296405/1266588

The answer presents an implementation of instanceof without the usage of dynamic_cast based on C++11, template metaprogramming and RTTI. A small performance measurement application demonstrates that it is more efficient than dynamic_cast if you use compiler optimization.

Answer 4

If you're willing to limit yourself to types known at compile-time (rather than working through pointers on instances of classes with vtables) - then C++11 and later does have an instanceof equivalent: It is std::is_base_of.

You might also want to check out std::is_convertible and std::is_same.

Answer 5

Don't do that. In most cases you should review your design when you ask for instanceof or dynamic_cast.

Why? You are most likely violating Liskov's substitiontin principle.

How about this approach:

class A {
   public:
     virtual void action();
     virtual ~A();
};

class B : public A {
   public: void action() override;
};

class C : public A {
   public: void action() override;
};

void on_event(A& obj)
{
   obj.action();
}

Note that as @Yakk pointed out you need at least one virtual method anyway to get dynamic polymorphism. And there is a rule that says: When you have at least one virtual method, always also write a virtual destructor in the base class.

You can do all this with templates and specialization or type tagging but I take from your question -- coming from Java -- you don't want to go there yet. You really like virtual methods, don't you? Sorry, that you have to mark them in C++.