如何在不从 QObject 派生的情况下使用 SIGNAL 和 SLOT？

Question

或其他方式来表达我的问题（虽然它没有解决我的问题）： 'QObject::QObject' 无法访问在类 'QObject' 中声明的私有成员

我需要类中的 SIGNAL 和 SLOTS 功能，但我认为如果不从其派生，这是不可能的QObject？

class MyClass
{
signals:
   importantSignal();
public slots:
   importantSlot();
};

问题似乎是我需要从 QObject 派生来使用信号和插槽......但我需要 MyClass 的默认构造函数。但由于 QObject 的以下功能，我无法构造它们： 没有复制构造函数或赋值运算符。

我尝试了很多......

所以我的应该类看起来像这样：

#include <QObject>
class MyClass: public QObject
{
    Q_OBJECT
public:
    explicit MyClass(QObject *parent = 0); //autogenerated by qtcreator for QObject derived class
    MyClass(const MyClass * other);

signals:
    importantSignal();
public slots:
    importantSlot();
};

我需要 MyClass 的默认构造函数。

那么是否有可能避免“'QObject::QObject'无法访问类'QObject'中声明的私有成员”错误？

或者作为替代方案，是否有可能在没有 QObject 的情况下使用信号和槽？

我很高兴收到任何建议。

Answer 1

如果您想要一个具有 QObject 功能的可复制对象，您需要成员资格（通过指针）而不是继承。

您可以从 QObject 派生类 Handler，其中 Handler 的插槽调用其父级上的 SomeInterface 虚拟函数。

struct NonQObjectHandler {
    virtual ~ NonQObjectHandler () {}
    virtual void receive (int, float) = 0;
};

class Handler : public NonQObjectHandler {
    struct Receiver;
    std :: unique_ptr <Receiver> m_receiver;
    void receive (int, float); // NonQObjectHandler
public:
    Handler ();
    Handler (const Handler &); // This is what you're really after
};

class Handler :: Receiver : public QObject {
Q_OBJECT
private:
    NonQObjectHandler * m_handler;
private slots:
    void receive (int, float); // Calls m_handler's receive
public:
    Receiver (NonQObjectHandler *);
};

Handler :: Handler ()
: m_receiver (new Receiver (this))
{
}

Handler :: Handler (const Handler & old)
: m_receiver (new Receiver (this))
{
    // Copy over any extra state variables also, but
    // Receiver is created anew.
}

Handler :: Receiver :: Receiver (NonQObjectHandler * h)
: m_handler (h)
{
    connect (foo, SIGNAL (bar (int, float)), this, SLOT (receive (int, float)));
}

void Handler :: Receiver :: receive (int i, float f)
{
    m_handler -> receive (i, f);
}

Answer 2

如果您想使用信号/槽模式实现事件驱动功能，但不想在 Qt 的范围内工作（即您想在需要复制构造函数的 STL 容器等内部使用您的类），我建议使用 Boost::signal。

否则，不，如果不从 QObject 派生，您就不可能做您想做的事情，因为该基类是处理 Qt 运行时信号/槽功能的。

Answer 3

如果不使用QObject/Q_OBJECT，则无法使用Qt 的信号/槽机制。

理论上，您可以创建一个虚拟 QObject 并将其组合到您的类中。然后，虚拟人会将插槽调用转发到您的班级。由于 Liz 在她的评论中描述的原因，您可能会遇到生命周期管理问题。

Answer 4

从 Qt5 开始你可以连接到任何函数

connect(&timer, &QTimer::finished,
        &instanceOfMyClass, &MyClass::fancyMemberFunction);

Answer 5

在 Qt5 中，您使用 QObject::connect 将 signal 与 slot 连接：

/*
   QMetaObject::Connection QObject::connect(
    const QObject *sender,
    const char *signal,
    const char *method,
    Qt::ConnectionType type = Qt::AutoConnection) const;
 */

#include <QApplication>
#include <QDebug>
#include <QLineEdit>

int main(int argc, char *argv[]) {
    QApplication app(argc, argv);
    QLineEdit lnedit;

    // connect signal `QLineEdit::textChanged` with slot `lambda function`
    QObject::connect(&lnedit, &QLineEdit::textChanged, [&](){qDebug()<<lnedit.text()<<endl;});

    lnedit.show();
    return app.exec();
}

结果：

Answer 6

仅仅因为 QObject 不可复制并不意味着您在复制或分配类等时必须复制它。具体来说，您需要做的就是将您的类与 QObject 的副本隔离和赋值运算符（因为它们已被删除）。

通常，您会将“可复制的不可复制的 QObject”分解为一个单独的类：

// main.cpp
#include <QObject>
#include <QVariant>

class CopyableQObject : public QObject
{
protected:
   explicit CopyableQObject(QObject* parent = nullptr) : QObject(parent) {}
   CopyableQObject(const CopyableQObject& other) { initFrom(other); }
   CopyableQObject(CopyableQObject&& other)      { initFrom(other); }
   CopyableQObject& operator=(const CopyableQObject& other)
   {
      return initFrom(other), *this;
   }
   CopyableQObject& operator=(CopyableQObject&& other)
   {
      return initFrom(other), *this;
   }
private:
   void initFrom(const CopyableQObject& other)
   {
      setParent(other.parent());
      setObjectName(other.objectName());
   }
   void initFrom(CopyableQObject& other)
   {
      initFrom(const_cast<const CopyableQObject&>(other));
      for (QObject* child : other.children())
         child->setParent( this );
      for (auto& name : other.dynamicPropertyNames())
         setProperty(name, other.property(name));
   }
};

您可以在 QObject 实例之间复制所需的任何属性。上面复制了父对象名称和对象名称。此外，当从另一个对象移动时，其子对象将被重新设置父级，并且动态属性名称也会被传输。

现在，CopyableQObject 适配器实现了所有允许派生类进行复制构造、复制分配、移动构造和移动分配的构造函数。

您的类需要做的就是从上面的适配器类派生：

class MyClass : public CopyableQObject
{
   Q_OBJECT
public:
   Q_SIGNAL void signal1();
   Q_SIGNAL void signal2();
};

我们可以测试它是否有效：

int main()
{
   int counter = 0;

   MyClass obj1;
   MyClass obj2;
   Q_SET_OBJECT_NAME(obj1);

   QObject::connect(&obj1, &MyClass::signal1, [&]{ counter += 0x1; });
   QObject::connect(&obj1, &MyClass::signal2, [&]{ counter += 0x10; });
   QObject::connect(&obj2, &MyClass::signal1, [&]{ counter += 0x100; });
   QObject::connect(&obj2, &MyClass::signal2, [&]{ counter += 0x1000; });

   Q_ASSERT(counter == 0);
   emit obj1.signal1();
   emit obj1.signal2();
   Q_ASSERT(counter == 0x11);

   QObject obj3(&obj1);
   Q_ASSERT(obj3.parent() == &obj1);
   const auto name1 = obj1.objectName();

   obj2 = std::move(obj1);

   Q_ASSERT(obj3.parent() == &obj2);
   Q_ASSERT(obj2.objectName() == name1);

   emit obj2.signal1();
   emit obj2.signal2();
   Q_ASSERT(counter == 0x1111);
}

#include "main.moc"

这就是完整的、可编译的示例。