Qt:如何为所有小部件和小部件类型实现通用基类信号/插槽功能(通过虚拟基类插槽)

class MySignaler : public QObject
{
    Q_OBJECT
    public:
        MySignaler : QObject(null_ptr) {}
    signals:
        void MySignal();
}
MySignaler signaler;
class MyBaseWidget: public QObject
{
    Q_OBJECT
    public:
        MyBaseWidget() : QObject(null_ptr)
        {
            connect(&signaler, SIGNAL(MySignal()), this, SLOT(MySlot()));
        }
    public slots:
        virtual void MySlot()
        {
            // Default behavior here
        }
}
// Not allowed!
// Cannot derive from two different QObject-derived base classes.
// How to gain functionality of both QTabWidget and the MyBaseWidget base class?
class MyTabWidget : public QTabWidget, public MyBaseWidget
{
    Q_OBJECT
    public slots:
        void MySlot()
        {
            // Decide to handle the signal for custom behavior
        }
}

有时当继承有问题时，可以用组合来代替它或它的一部分。

这是Qt 4中需要的方法:而不是从QObject派生，从非QObject类(MyObjectShared)派生，该类携带辅助QObject，用作代理将信号连接到其插槽;helper将该调用转发给非QObject类。

在Qt 5中，根本不需要从QObject派生:信号可以连接到任意函子。MyObjectShared类保持不变。

如果Qt 4兼容性在代码的其他领域通常有用，可以使用通用的connect函数将信号连接到Qt 4和Qt 5中的函子(在Qt 4中，它将使用隐式的辅助QObject)。

// https://github.com/KubaO/stackoverflown/tree/master/questions/main.cpp
#include <QtCore>
#include <functional>
#include <type_traits>
class MySignaler : public QObject {
   Q_OBJECT
  public:
   Q_SIGNAL void mySignal();
} signaler;
#if QT_VERSION < 0x050000
class MyObjectShared;
class MyObjectHelper : public QObject {
   Q_OBJECT
   MyObjectShared *m_object;
   void (MyObjectShared::*m_slot)();
  public:
   MyObjectHelper(MyObjectShared *object, void (MyObjectShared::*slot)())
       : m_object(object), m_slot(slot) {
      QObject::connect(&signaler, SIGNAL(mySignal()), this, SLOT(slot()));
   }
   Q_SLOT void slot() { (m_object->*m_slot)(); }
};
#endif
class MyObjectShared {
   Q_DISABLE_COPY(MyObjectShared)
#if QT_VERSION < 0x050000
   MyObjectHelper helper;
  public:
   template <typename Derived>
   MyObjectShared(Derived *derived) : helper(derived, &MyObjectShared::mySlot) {}
#else
  public:
   template <typename Derived, typename = typename std::enable_if<
                                   std::is_base_of<MyObjectShared, Derived>::value>::type>
   MyObjectShared(Derived *derived) {
      QObject::connect(&signaler, &MySignaler::mySignal,
                       std::bind(&MyObjectShared::mySlot, derived));
   }
#endif
   bool baseSlotCalled = false;
   virtual void mySlot() { baseSlotCalled = true; }
};
class MyObject : public QObject, public MyObjectShared {
   Q_OBJECT
  public:
   MyObject(QObject *parent = nullptr) : QObject(parent), MyObjectShared(this) {}
   // optional, needed only in this immediately derived class if you want the slot to be a
   // real slot instrumented by Qt
#ifdef Q_MOC_RUN
   void mySlot();
#endif
};
class MyDerived : public MyObject {
  public:
   bool derivedSlotCalled = false;
   void mySlot() override { derivedSlotCalled = true; }
};
void test1() {
   MyObject base;
   MyDerived derived;
   Q_ASSERT(!base.baseSlotCalled);
   Q_ASSERT(!derived.baseSlotCalled && !derived.derivedSlotCalled);
   signaler.mySignal();
   Q_ASSERT(base.baseSlotCalled);
   Q_ASSERT(!derived.baseSlotCalled && derived.derivedSlotCalled);
}
int main(int argc, char *argv[]) {
   test1();
   QCoreApplication app(argc, argv);
   test1();
   return 0;
}
#include "main.moc"

要在两个QObject之间共享一些代码，可以将QObject作为类的成员，这是一个插入的非对象类，它使用泛型类，仅在基类型上参数化。泛型类可以有槽和信号。它们必须只在直接派生的类中对moc可见，而不能在任何进一步派生的类中可见。

唉，您通常不能在类的构造函数中连接任何泛型类的信号或槽，因为此时派生类尚未构造，并且它的元数据不可用—从Qt的角度来看，信号和槽并不存在。所以Qt 4风格的运行时检查的connect将失败。

编译时检查的connect甚至不会编译，因为它工作的this指针有一个不正确的编译时类型，而您对派生类的类型一无所知。

对于Qt-4风格连接的一个解决方法是有一个doConnections方法，派生构造函数必须调用该方法，在该方法中进行连接。

因此，让我们在基类和派生类上使泛型类参数化——后者被称为好奇循环模板模式，或简称CRTP。

现在您可以访问派生类的类型，并且可以使用辅助函数将this转换为指向派生类的指针，并在Qt 5风格的编译时间检查connect s中使用它。

Qt 4风格的运行时检查connect仍然需要从doConnections调用。所以，如果你使用Qt 5，这不是问题。无论如何，你不应该在Qt 5代码中使用Qt 4风格的connect。

根据直接从泛型类派生的类是否覆盖它们，插槽需要稍微不同的处理。

如果插槽是虚拟的并且在直接派生的类中有实现，您应该以正常的方式将其公开给moc -使用slots节或Q_SLOT宏。

如果插槽在直接派生的类中没有实现(无论是否为虚的)，那么它在泛型类中的实现应该只对moc可见，而不是对编译器可见——毕竟您不希望重写它。因此，插槽声明被包装在#ifdef Q_MOC_RUN块中，该块仅在moc读取代码时才活动。生成的代码将引用槽的通用实现。

由于我们希望确保这确实有效，我们将添加一些布尔值来跟踪插槽是否被调用。

// main.cpp
#include <QtWidgets>
template <class Base, class Derived> class MyGenericView : public Base {
   inline Derived* dthis() { return static_cast<Derived*>(this); }
public:
   bool slot1Invoked, slot2Invoked, baseSlot3Invoked;
   MyGenericView(QWidget * parent = 0) : Base(parent),
      slot1Invoked(false), slot2Invoked(false), baseSlot3Invoked(false)
   {
      QObject::connect(dthis(), &Derived::mySignal, dthis(), &Derived::mySlot2); // Qt 5 style
      QObject::connect(dthis(), &Derived::mySignal, dthis(), &Derived::mySlot3);
   }
   void doConnections() {
      Q_ASSERT(qobject_cast<Derived*>(this)); // we must be of correct type at this point
      QObject::connect(this, SIGNAL(mySignal()), SLOT(mySlot1())); // Qt 4 style
   }
   void mySlot1() { slot1Invoked = true; }
   void mySlot2() { slot2Invoked = true; }
   virtual void mySlot3() { baseSlot3Invoked = true; }
   void emitMySignal() {
      emit dthis()->mySignal();
   }
};

泛型类使用起来非常简单。记住将所有非虚拟覆盖的插槽包装在一个仅用于moc的保护中!

还记得适用于所有Qt代码的一般规则:如果你有一个槽，它应该只声明一次moc。因此，如果您有一个进一步派生自MyTreeWidget或MyTableWidget的类，则不希望在任何必要的虚拟插槽覆盖之前使用Q_SLOT或slots宏。如果存在，它会微妙地破坏东西。但是你肯定需要Q_DECL_OVERRIDE。

如果你在Qt 4上，记得调用doConnections，否则这个方法是不必要的。

QTreeWidget和QTableWidget的特定选择完全是任意的，没有意义的，不应该被认为这样的使用有任何意义(很可能没有意义)。

class MyTreeWidget : public MyGenericView<QTreeWidget, MyTreeWidget> {
   Q_OBJECT
public:
   bool slot3Invoked;
   MyTreeWidget(QWidget * parent = 0) : MyGenericView(parent), slot3Invoked(false) { doConnections(); }
   Q_SIGNAL void mySignal();
#ifdef Q_MOC_RUN // for slots not overridden here
   Q_SLOT void mySlot1();
   Q_SLOT void mySlot2();
#endif
   // visible to the C++ compiler since we override it
   Q_SLOT void mySlot3() Q_DECL_OVERRIDE { slot3Invoked = true; }
};
class LaterTreeWidget : public MyTreeWidget {
   Q_OBJECT
public:
   void mySlot3() Q_DECL_OVERRIDE { } // no Q_SLOT macro - it's already a slot!
};
class MyTableWidget : public MyGenericView<QTreeWidget, MyTableWidget> {
   Q_OBJECT
public:
   MyTableWidget(QWidget * parent = 0) : MyGenericView(parent) { doConnections(); }
   Q_SIGNAL void mySignal();
#ifdef Q_MOC_RUN
   Q_SLOT void mySlot1();
   Q_SLOT void mySlot2();
   Q_SLOT void mySlot3(); // for MOC only since we don't override it
#endif
};

最后，这个小测试用例显示它确实按预期工作。

int main(int argc, char *argv[])
{
   QApplication a(argc, argv);
   MyTreeWidget tree;
   MyTableWidget table;
   Q_ASSERT(!tree.slot1Invoked && !tree.slot2Invoked && !tree.slot3Invoked);
   emit tree.mySignal();
   Q_ASSERT(tree.slot1Invoked && tree.slot2Invoked && tree.slot3Invoked);
   Q_ASSERT(!table.slot1Invoked && !table.slot2Invoked && !table.baseSlot3Invoked);
   emit table.mySignal();
   Q_ASSERT(table.slot1Invoked && table.slot2Invoked && table.baseSlot3Invoked);
   return 0;
}
#include "main.moc"

这个方法给你如下:

1. 公共代码类派生自基类，因此可以很容易地调用或覆盖基类的行为。在这个特定的示例中，您可以重新实现QAbstractItemView方法等。

2. 完全支持信号和槽位。即使在派生类的元数据中声明了信号和插槽，您仍然可以在泛型类中使用它们。

在这种情况下，您可以使用组合而不是多重继承。像这样:

class MySignaler : public QObject
{
    Q_OBJECT
    public:
        MySignaler : QObject(NULL) {}
    signals:
        void MySignal();
}
MySignaler signaler;
class MyBaseWidgetContainer: public QWidget
{
    Q_OBJECT
    public:
        MyBaseWidgetContainer() : QObject(NULL), widget(NULL)
        {
            connect(&signaler, SIGNAL(MySignal()), this, SLOT(MySlot()));
        }
    public slots:
        virtual void MySlot()
        {
            // Default behavior here
        }
    private:
        QWidget *widget;
}
class MyTabWidgetContainer : public MyBaseWidgetContainer
{
    Q_OBJECT
    public:
        MyTabWidgetContainer() {
            widget = new QTabWidget(this);
            QLayout *layout = new QBoxLayout(this);
            layout->addWidget(widget);
        }
    public slots:
        void MySlot()
        {
            // Decide to handle the signal for custom behavior
        }
}