试图将基数 class 指针转换为派生 class object 实现的接口

Question

I am experimenting a little bit with inheritance in C++ and I stepped on a case that I don't quite understand. When I try to compile the code I get:

error: cannot 'dynamic_cast' 'base' (of type 'class Base*') to type 'class SomeInterface*' (source type is not polymorphic)

I assume that it is not a proper way of casting, because SomeInterface is not related to Base, but is there a way to make it work? Maybe there something I can add to the class to make static_cast possible? Or is it just a bad architecture and I should rearrange my code to not introduce cases like this one? I'd appreciate any comments or resources I could read to understand this behaviour and possibly learn how to make it work.

class Base
{
    
};

class SomeInterface
{
    
public:
    void call_me() { }
};

class Derived : public Base, public SomeInterface
{

};

void try_call_me(Base* base)
{
    // line below causes an error
    SomeInterface* some_interface_instance = dynamic_cast<SomeInterface*>(base);
    some_interface_instance->call_me();
}


int main()
{
    Derived derived_instance;
    Base* base_instance = &derived_instance;
    
    try_call_me(base_instance);
    return 0;
}

Answer 1

dynamic_cast requires (except for up-casts) that the base class type used in the argument is polymorphic .

A class in C++ is called polymorphic if it has at least one virtual function. So you need to add one to your Base , for example the destructor:

struct Base
{
    virtual ~Base() = default;
};

Polymorphic classes store additional information that is required for dynamic_cast to work at runtime.

However, that is a costly operation to do. Reconsider why try_call_me is expecting a pointer to Base instead of SomeInterface if that is really what it needs.

If you keep it as it is, you also need to add error checking to the dynamic_cast . It will return a null pointer if base doesn't refer to an object whose most-derived object contain a SomeInterface base class subobject that could be side-casted to:

SomeInterface* some_interface_instance = dynamic_cast<SomeInterface*>(base);
if(!some_interface_instance) {
    // didn't pass a suitable pointer, error!
    // fail here, otherwise there will be undefined behavior!
} else {
    some_interface_instance->call_me();
}

(If you use references instead of pointers, dynamic_cast will throw an exception instead of producing a null pointer value.)