dynamic_cast doesn't work across .sofiles loaded with dlopen:

https://stackoverflow.com/questions/23383102/dynamic-cast-tr...

I've seen it first hand crap itself on Mac OS X. The gist of it is that if you have a plugin architecture, you can't pass an object allocated in one plugin to another and have the latter do a dynamic_cast. For the same reason exceptions thrown in a plugin can't be caught in another unless the type is defined in the host binary. I.e. suppose the main application has:

    class HostException {
        virtual ~HostException() {}
    };

    class FooInterface {
        virtual void doBar()=0;
    };

Then inside plugin A you do

    try {
        foo->doBar();
    } catch (HostException& ex) {
        // stuff
    }

where foo was allocated in plugin B. Then,

    // in plugin B
    class FooImpl : public FooInterface {
        virtual void doBar() override;
    };
    class MyException : public HostException {
        virtual ~MyException() {}
    };
    void FooImpl::doBar() {
        throw HostException(); // should be just fine
        throw MyException(); // here be dragons
    }

For that reason in places where we call foreign code that we know could throw we just do a blanket catch(...) and bail out on any exception. Similarly we don't rely on dynamic casts at all anywhere, we use our own type system.

The OOP features of C++ are fine for small toy programs but ironically they break when you try to use them for actual large ones that would benefit the most from them. Stick to virtual functions, static and reinterpret casts and nothing else.