Question

If I declare a function virtual in the base non-QObject class and then overlaod it as a slot in the derived class that has Q_OBJECT macro and that has QObject as one of the base classes is it supposed to work ok?

Is it guaranteed that virtual calls will work? What should happen if you connenct to the slot of the derived class?

class Base
{
public:
    virtual void f();
};

class Derived: public QObject, public Base
{
    Q_OBJECT
public slots:
    virtual void f();
};

Answer 1

Yes:

Since slots are normal member functions, they follow the normal C++
rules when called directly. <…> You can also define slots to be virtual, which we have found quite
useful in practice.

http://qt-project.org/doc/qt-4.8/signalsandslots.html#slots

In your example Derived::f is a normal virtual function. If it’s called directly, it works as expected, just as the documentation says. When invoked by signal, it’s called by qt_static_metacall, which is generated in moc_Derived.cpp as following:

void Derived::qt_static_metacall(QObject *_o, QMetaObject::Call _c, 
                                 int _id,     void **_a)
{
    if (_c == QMetaObject::InvokeMetaMethod) {
        Q_ASSERT(staticMetaObject.cast(_o));
        Derived *_t = static_cast<Derived *>(_o);
        switch (_id) {
        case 0: _t->f(); break;
        default: ;
        }
    }
    Q_UNUSED(_a);
}

So, it ends with normal function call _t->f().

Note that there is no way to invoke Base::f by a signal. This function can be executed only if present object is actually Base instance and not Derived instance. And since Base is not QObject-based, you can’t pass its instance to connect function.