How to connect an abstract signal to a slot within the interface's constructor?

Question

I have an abstract class that contains the pure virtual signal and a class derived from QObject. I want to connect that signal to derived class's slot.

class MSys : public QObject
{
    Q_OBJECT
public:
    explicit MSys(QObject *parent = 0) : QObject(parent) {}
    virtual ~MSys() {}

public slots:
    void onRequset();
};

class AbsView
{
protected:
    AbsView() : m_sys(new MSys)
    {
    // QObject::connect(this, SIGNAL(request()), m_sys, SLOT(onRequset()));
    /* What can I do here !? */
    }

public:
    virtual ~AbsView() {}

signals:
    virtual void request() = 0;

private:
    MSys *m_sys;
};

Q_DECLARE_INTERFACE(AbsView, "AbsView")

This isn't a problem once the constructor is finished: then the dynamic_cast<QObject*>(this) will work within any of interface's methods. But within the constructor, it seems impossible.

Is there some way of doing it?

Answer 1

Generally speaking, interfaces should be abstract classes, and their constructors shouldn't be doing anything at all. So this is bad design.

If you insist on doing things such way, the semantics of C++ prevents us from doing it exactly as you state. When you multiply-inherit, a dynamic_cast to C will fail until the constructor of C is entered:

struct Interface {
  Interface() { assert(dynamic_cast<QObject*>(this) == 0); }
};

struct C : public QObject, public Interface {
  C() { assert(dynamic_cast<QObject*>(this)); }
};

So, we need some way of delaying the connection until the full object has been constructed, or at least until the QObject part of it is available.

A simple way would be for the interface to explicitly require the base to be constructed:

struct Interface {
  Interface(QObject * base) {
    connect(base, ...);
  }
};

struct C : public QObject, public Interface {
  C() : Interface(this) {}
};

The constructor signature nicely expresses the intent: Interface is meant to be used on classes deriving from QObject. It will not work on those that don't.

Another way is to delay the connection until the event loop has had a chance to run. This is acceptable if the connection isn't needed sooner than that. This doesn't require the Interface constructor to be passed an explicit pointer to the base class.

The timer is owned by the event dispatcher for the current thread, that way it won't leak even if the event loop isn't ever started.

class Interface {
public:
  virtual void request() = 0; // entirely optional
  Interface() {
    auto timer = new QTimer(QAbstractEventDispatcher::instance());
    timer.start(0);
    QObject::connect(timer, &QTimer::timeout, [this, timer]{
      timer.deleteLater();
      connect(dynamic_cast<QObject*>(this), SIGNAL(request()), ...);
    });    
  }
};

Please note that in all cases it's entirely superfluous to have the signal declared virtual in the interface. The Interface's constructor can check if the signal is present, and assert it, or even always abort().

Merely by declaring a virtual signal doesn't guarantee that the signal is actually a signal. The following will not work, even though the compiler provides no diagnostics to the contrary:

struct Interface {
  signals:
    virtual void aSignal() = 0;
};

struct Implementation : public QObject, public Interface {
  void aSignal() {} // not really a signal!
};

This will detect the missing signal at runtime:

struct Interface {
  // No need for virtual signal!
  Interface(QObject * base) {
    Q_ASSERT(base->metaObject()->indexOfSignal("request()") != -1);
  }
};

struct Implementation : public QObject, public Interface {
  Q_OBJECT
  Q_SIGNAL void reuest(); // a typo
  Implementation() : Interface(this) {} // will assert!
};

The best way to ensure that the virtual signal is followed could be to do both, and to declare the signal implementation as an override:

struct Interface {
  virtual void aSignal() = 0;
  Interface(QObject * base) {
    Q_ASSERT(base->metaObject()->indexOfSignal("request()") != -1);
  }
};

struct Implementation : public QObject, public Interface {
  Q_OBJECT
  Q_SIGNAL void request() Q_DECL_OVERRIDE;
  Implementation() : Interface(this) {}
};

The compiler will catch typos even if you never instantiate the Implementation, and the interface will check at runtime that the implementation's signal is actually a signal, and not some other method.

It must also be noted that the signals: section of the Interface is bogus.

1. signals is a preprocessor macro with empty expansion: to the compiler, it does nothing.

2. Interface is not a QObject, and is thus ignored by the moc.

3. signals: is only meaningful to moc iff it is in a class that both:

   • derives from QObject, and
   • contains the Q_OBJECT macro.

Generally speaking, virtual signals make little sense. They are all "virtual" in the sense that you can connect things without giving the compiler a virtual method.

Finally, they don't work with the Qt 5 compile-time-verified syntax either, since Interface is not a concrete QObject-deriving class with a proper signal