在接口类中声明抽象信号

Question

当实现类已经从QObject/QWidget中获取时,如何在抽象类/接口中声明Qt信号？

class IEmitSomething
{
   public:
     // this should be the signal known to others
     virtual void someThingHappened() = 0;
}

class ImplementEmitterOfSomething : public QWidget, public IEmitSomething
{
     // signal implementation should be generated here
     signals: void someThingHappended();
}

Answer 1

正如我在最后几天发现的那样...... Qt这样做的方式是这样的:

class IEmitSomething
{
   public:
     virtual ~IEmitSomething(){} // do not forget this

   signals: // <- ignored by moc and only serves as documentation aid
            // The code will work exactly the same if signals: is absent.
     virtual void someThingHappened() = 0;
}

Q_DECLARE_INTERFACE(IEmitSomething, "IEmitSomething") // define this out of namespace scope

class ImplementEmitterOfSomething : public QWidget, public IEmitSomething
{
   Q_OBJECT
   Q_INTERFACES(IEmitSomething)

   signals:
      void someThingHappended();
}

现在您可以连接到那些接口信号.

如果在连接信号时无法访问实现,则connect语句将需要动态强制转换为QObject:

IEmitSomething* es = ... // your implementation class

connect(dynamic_cast<QObject*>(es), SIGNAL(someThingHappended()), ...);

...这样你就不会被迫将实现类暴露给订阅者和客户端.是啊!

Answer 2

在Qt中,"信号"是"受保护"的同义词.但它有助于MOC生成必要的代码.因此,如果您需要具有某些信号的接口 - 您应该将它们声明为虚拟抽象保护方法.所有必要的代码都将由MOC生成 - 您可能会看到详细信息,"发出一些信号"将被替换为具有相同名称的受保护方法的虚拟调用.注意,用Qt生成的方法体.

更新:示例代码:

MyInterfaces.h

#pragma once

struct MyInterface1
{
signals:
    virtual void event1() = 0;
};

struct MyInterface2
{
signals:
    virtual void event2() = 0;
};

MyImpl.h

#ifndef MYIMPL_H
#define MYIMPL_H

#include <QObject>
#include "MyInterfaces.h"

class MyImpl
    : public QObject
    , public MyInterface1
    , public MyInterface2
{
    Q_OBJECT

public:
    MyImpl( QObject *parent );
    ~MyImpl();

    void doWork();

signals:
    void event1();
    void event2();
};

class MyListner
    : public QObject
{
    Q_OBJECT

public:
    MyListner( QObject *parent );
    ~MyListner();

public slots:
    void on1();
    void on2();
};

#endif // MYIMPL_H

MyImpl.cpp

#include "MyImpl.h"
#include <QDebug>

MyImpl::MyImpl(QObject *parent)
    : QObject(parent)
{}

MyImpl::~MyImpl()
{}

void MyImpl::doWork()
{
    emit event1();
    emit event2();
}

MyListner::MyListner( QObject *parent )
{}

MyListner::~MyListner()
{}

void MyListner::on1()
{
    qDebug() << "on1";
}

void MyListner::on2()
{
    qDebug() << "on2";
}

main.cpp中

#include <QCoreApplication>
#include "MyImpl.h"

int main( int argc, char *argv[] )
{
    QCoreApplication a( argc, argv );

    MyImpl *invoker = new MyImpl( NULL );
    MyListner *listner = new MyListner( NULL );

    MyInterface1 *i1 = invoker;
    MyInterface2 *i2 = invoker;

    // i1, i2 - not QObjects, but we are sure, that they will be.
    QObject::connect( dynamic_cast< QObject * >( i1 ), SIGNAL( event1() ), listner, SLOT( on1() ) );
    QObject::connect( dynamic_cast< QObject * >( i2 ), SIGNAL( event2() ), listner, SLOT( on2() ) );

    invoker->doWork();

    return a.exec();
}

Answer 3

在接口中将信号声明为抽象方法有两个问题：

1. 从 Qt 的角度来看，信号是仅在以特定方式实现时的信号- 即当实现由 moc 生成并包含在对象的元数据中时。

2. 直接从物体外部发射信号通常是糟糕的设计。

作为推论，由于接口是抽象的，您根本不需要声明它的信号 - 除了记录意图之外，它没有任何作用，因为：

1. 如果信号在派生自接口的类中实现，您可以使用元对象系统来验证它的存在。

2. 无论如何，您不应该直接调用这些信号方法。

3. 一旦您将非对象接口动态转换为QObject，实现是否从接口派生就不再重要了。

进行这种体操的唯一有效理由是：

1. 哄骗 doxygen 或其他文档生成器为您的代码提供文档。

2. 强制具体类具有同名方法的实现。这当然不能保证它实际上是一个信号。