Check if an instance is or inherits from a class, with the "class" being set at runtime

Question

I want to create a vector of "types", then check if an instance of an object is or inherits from any of the types inside this vector.

In C#, I can achieve this result with this code:

public bool IsOrInheritsFrom(SomeClass instance, Type type)
{
    Type instanceType = instance.GetType();
    return instanceType == type || instanceType .IsSubclassOf(type);
}

I have spent hours trying to reproduce this in C++ without success. All the other answers on Stackoverflow are only valid if you already know the type (using dynamic_cast), or if you want to compare two instances (with std::decay<decltype>).

Is it possible at all?

My goal is to have a flexible way to check if an instance belongs to one of the classes provided by "the client" of my code. The list of validTypes would be the part that needs to be flexible.

Example of what I want to achieve with pseudo code:

vector<Types> validTypes;
validTypes.push_back(Dog);
validTypes.push_back(Cat);
validTypes.push_back(Hamster);

Labrador* somePet = new Labrador();

for(Type t : validTypes ){
    // Returns true because Labrador inherits from Dog
    if( isOrInheritsFrom(somePet, t) ){
        return true;
    }
}

Answer 1

The short answer is no.

The longer answer is that C++ is very rigid on one point: all types are static. So while we can do things like creating lists of types, passing types as parameters, and so on, all of that is done with templates, and it all happens entirely at compile time.

If you really and truly need this, you're pretty much stuck with using values rather than types. That will probably involve each Action storing a list of values that are unique to particular types, and doing a search at runtime to figure out whether a particular value is in its list at any given time.

At least offhand, this strikes me as creating a situation that's (at best) incredibly confusing for the user. If I, as a user, try to do something one day, and it works, but try to do the same thing few minutes later or the next day and it doesn't work, I usually think of that as a bug. But at least as far as I can tell, that seems to be precisely what you're trying to do.

Answer 2

As far as I know, there are three situations where the type of an object is looked up at runtime: with dynamic_cast, binding exception objects to handlers and looking up which virtual function to call.

Here's an implementation of using exception handlers to store type information at runtime: https://godbolt.org/z/Mf71bbr7P

#include <type_traits>
#include <typeinfo>

namespace detail {
    template<typename T>
    struct CType;
}

struct Type {
    const std::type_info& type_info;

    template<typename T>
    friend struct detail::CType;

    template<typename T>
    friend bool IsOrInheritsFrom(const T&, const Type& type) noexcept {
        return type.can_catch_thrown_pointer([]{ throw static_cast<T*>(nullptr); });
    }

    Type(const Type&) = delete;
    Type& operator=(const Type&) = delete;
private:
    constexpr Type(const std::type_info& ti) noexcept : type_info(ti) {}
    ~Type() = default;
    virtual bool can_catch_thrown_pointer(void thrower()) const noexcept = 0;
};

namespace detail {
    template<typename T>
    struct CType : Type {
        static const CType instance;
    private:
        constexpr CType() noexcept : Type(typeid(T)) {}
        ~CType() = default;
        bool can_catch_thrown_pointer(void thrower()) const noexcept override {
            try {
                thrower();
            } catch (T*) {
                return true;
            } catch (...) {}
            return false;
        }
    };

    template<typename T>
    constexpr CType<T> CType<T>::instance{}; 
}

template<typename T>
constexpr const Type& TypeOf = detail::CType<typename std::remove_cv<typename std::remove_reference<T>::type>::type>::instance;


#include <vector>
#include <iostream>

struct Dog {};
struct Cat {};
struct Hamster {};
struct Labrador : Dog {};

int main() {
    std::vector<const Type*> validTypes;
    validTypes.push_back(&TypeOf<Dog>);
    validTypes.push_back(&TypeOf<Cat>);
    validTypes.push_back(&TypeOf<Hamster>);

    Labrador* somePet = new Labrador();

    for (const Type* t : validTypes) {
        if (IsOrInheritsFrom(*somePet, *t)) {
            std::cout << "Inherits from " << t->type_info.name() << '\n';
        } else {
            std::cout << "Does not inherit from " << t->type_info.name() << '\n';
        }
    }
}

Which throws (Labrador*) nullptr and each type in the vector sees if it can catch it. And it can be caught as a Dog*.

---

You can do something similar with dynamic_cast. The only way I can think of doing it is having a common base class between all types you want to be able to check, then each runtime type can try to dynamic_cast: https://godbolt.org/z/s9oearhGP

#include <type_traits>
#include <typeinfo>
#include <memory>

struct RuntimeTypeCheckable {
protected:
    RuntimeTypeCheckable() = default;
    RuntimeTypeCheckable(const RuntimeTypeCheckable&) = default;
    RuntimeTypeCheckable& operator=(const RuntimeTypeCheckable&) = default;
    virtual ~RuntimeTypeCheckable() = default;
};

namespace detail {
    template<typename T>
    struct CType;
}

struct Type {
    const std::type_info& type_info;

    template<typename T>
    friend struct detail::CType;

    template<typename T>
    friend bool IsOrInheritsFrom(const T& object, const Type& type) noexcept {
        return type.can_dynamic_cast_pointer(std::addressof(object));
    }

    Type(const Type&) = delete;
    Type& operator=(const Type&) = delete;
private:
    constexpr Type(const std::type_info& ti) noexcept : type_info(ti) {}
    ~Type() = default;
    virtual bool can_dynamic_cast_pointer(const RuntimeTypeCheckable* ptr) const noexcept = 0;
};

namespace detail {
    template<typename T>
    struct CType : Type {
        static const CType instance;
    private:
        constexpr CType() noexcept : Type(typeid(T)) {}
        ~CType() = default;
        bool can_dynamic_cast_pointer(const RuntimeTypeCheckable* ptr) const noexcept override {
            return dynamic_cast<const T*>(ptr) != nullptr;
        }
    };

    template<typename T>
    constexpr CType<T> CType<T>::instance{}; 
}

template<typename T>
constexpr const Type& TypeOf = detail::CType<typename std::remove_cv<typename std::remove_reference<T>::type>::type>::instance;


#include <vector>
#include <iostream>

struct Dog : virtual RuntimeTypeCheckable {};
struct Cat : virtual RuntimeTypeCheckable {};
struct Hamster : virtual RuntimeTypeCheckable {};
struct Labrador : Dog {};

int main() {
    std::vector<const Type*> validTypes;
    validTypes.push_back(&TypeOf<Dog>);
    validTypes.push_back(&TypeOf<Cat>);
    validTypes.push_back(&TypeOf<Hamster>);

    Labrador* somePet = new Labrador();

    for (const Type* t : validTypes) {
        if (IsOrInheritsFrom(*somePet, *t)) {
            std::cout << "Inherits from " << t->type_info.name() << '\n';
        } else {
            std::cout << "Does not inherit from " << t->type_info.name() << '\n';
        }
    }
}

Though this requires the types to have RuntimeTypeCheckable as a base class.

---

As for virtual functions, you would need something like this: https://godbolt.org/z/jq6b8E7bx

#include <typeinfo>

struct RuntimeTypeCheckable {
public:
    virtual bool is_or_inherits_from(const std::type_info& type_info) const noexcept {
        return type_info == typeid(RuntimeTypeCheckable);
    }

    friend bool IsOrInheritsFrom(const RuntimeTypeCheckable& object, const std::type_info& type) noexcept {
        return object.is_or_inherits_from(type);
    }
protected:
    RuntimeTypeCheckable() = default;
    RuntimeTypeCheckable(const RuntimeTypeCheckable&) = default;
    RuntimeTypeCheckable& operator=(const RuntimeTypeCheckable&) = default;
    virtual ~RuntimeTypeCheckable() = default;
};


#include <typeindex>
#include <vector>
#include <iostream>

struct Dog : virtual RuntimeTypeCheckable {
    bool is_or_inherits_from(const std::type_info& type_info) const noexcept override {
        return type_info == typeid(Dog) || RuntimeTypeCheckable::is_or_inherits_from(type_info);
    }
};
struct Cat : virtual RuntimeTypeCheckable {
    bool is_or_inherits_from(const std::type_info& type_info) const noexcept override {
        return type_info == typeid(Dog) || RuntimeTypeCheckable::is_or_inherits_from(type_info);
    }
};
struct Hamster : virtual RuntimeTypeCheckable {
    bool is_or_inherits_from(const std::type_info& type_info) const noexcept override {
        return type_info == typeid(Dog) || RuntimeTypeCheckable::is_or_inherits_from(type_info);
    }
};
struct Labrador : Dog {
    bool is_or_inherits_from(const std::type_info& type_info) const noexcept override {
        return type_info == typeid(Labrador) || Dog::is_or_inherits_from(type_info);
    }
};

int main() {
    std::vector<const std::type_info*> validTypes;
    validTypes.push_back(&typeid(Dog));
    validTypes.push_back(&typeid(Cat));
    validTypes.push_back(&typeid(Hamster));

    Labrador* somePet = new Labrador();

    for (const std::type_info* t : validTypes) {
        if (IsOrInheritsFrom(*somePet, *t)) {
            std::cout << "Inherits from " << t->name() << '\n';
        } else {
            std::cout << "Does not inherit from " << t->name() << '\n';
        }
    }
}

Which requires the most modifications to the types being used, but is the most readable. The boilerplate can be reduced with CRTP.