What is the C++ Equivalent of Java's `instanceof` Operator?

How can I achieve the functionality of Java's `instanceof` in C++?

// Example of dynamic_cast in C++ to check type compatibility
class Base {};
class Derived : public Base {};

Base* basePtr = new Derived();
if (dynamic_cast<Derived*>(basePtr)) {
    // It's a Derived type!
} else {
    // It's not a Derived type.
}

In C++, the equivalent functionality to Java's `instanceof` operator can be achieved using **Run-Time Type Information (RTTI)** and the `dynamic_cast` operator. This allows you to determine whether a pointer or reference points to an object of a specific derived class.

// Check if a base pointer points to a derived object
#include <iostream>
#include <typeinfo>

class Base {
public:
    virtual ~Base() {} // Ensure there is a virtual function
};

class Derived : public Base {};

int main() {
    Base* basePtr = new Derived();
    if (Derived* derivedPtr = dynamic_cast<Derived*>(basePtr)) {
        std::cout << "It's a Derived type!" << std::endl;
    } else {
        std::cout << "It's not a Derived type." << std::endl;
    }
    delete basePtr;
    return 0;
}

Causes

• Understanding object-oriented programming concepts such as inheritance and polymorphism.
• RTTI being part of the C++ standard that enables type checking at runtime.

Solutions

• Use `dynamic_cast` to safely check the type of an object at runtime.
• Ensure that the base class has at least one virtual function to enable RTTI.
• Utilize the typeid operator for more type information, though less safe than `dynamic_cast`.

Mistake: Not using a virtual function in the base class.

Solution: Always declare at least one virtual function in your base class to enable RTTI.

Mistake: Using static_cast instead of dynamic_cast for type checking.

Solution: Use dynamic_cast for safe runtime checks, static_cast does not perform runtime checks.