我通过使用自定义的moc输出文件(通过将生成的文件移动到我的源中并随后从我的.pro文件中删除类’标题)为助手QObject编写了一个自定义的qt_static_Metacall.我需要小心,但它似乎远不如我在问题中建议的解决方案那么脏.

对于具有一些插槽的类,这里例如两个插槽exampleA(int)和exampleB(bool),它的定义如下：

void ClassName::qt_static_Metacall(QObject *_o,QMetaObject::Call _c,int _id,void **_a)
{
    if (_c == QMetaObject::InvokeMetaMethod) {
        Q_ASSERT(staticMetaObject.cast(_o));
        ClassName *_t = static_cast<ClassName *>(_o);
        switch (_id) {
        case 0: _t->exampleA((*reinterpret_cast< int(*)>(_a[1]))); break;
        case 1: _t->exampleB((*reinterpret_cast< bool(*)>(_a[1]))); break;
        default: ;
        }
    }
}

如您所见,它将调用重定向到被调用者提供的对象指针上的“真实”方法.

我用一些没有任何参数的插槽创建了一个类,它将被用作我们想要检查的信号的目标.

class GenericSignalMapper : public QObject
{
    Q_OBJECT
public:
    explicit GenericSignalMapper(QMetaMethod mappedMethod,QObject *parent = 0);
signals:
    void mapped(QObject *sender,QMetaMethod signal,QVariantList arguments);
public slots:
    void map();
private:
    void internalSignalHandler(void **arguments);
    QMetaMethod method;
};

插槽map()永远不会被实际调用,因为我们通过将自己的方法放在qt_static_Metacall中来介入此调用过程(请注意,ID为0的元方法是我在下一节中解释的另一个信号,因此修改后的方法是案例1)：

void GenericSignalMapper::qt_static_Metacall(QObject *_o,void **_a)
{
    if (_c == QMetaObject::InvokeMetaMethod) {
        Q_ASSERT(staticMetaObject.cast(_o));
        GenericSignalMapper *_t = static_cast<GenericSignalMapper *>(_o);
        switch (_id) {
        case 0: _t->mapped((*reinterpret_cast< QObject*(*)>(_a[1])),(*reinterpret_cast< QMetaMethod(*)>(_a[2])),(*reinterpret_cast< QVariantList(*)>(_a[3]))); break;
        case 1: _t->internalSignalHandler(_a); break;
        default: ;
        }
    }
}

我们所做的是：我们只是将未解释的参数数组传递给我们自己的处理程序,因为我们不能具体说明它的类型(甚至是计数).我定义了这个处理程序如下：

void GenericSignalMapper::internalSignalHandler(void **_a)
{
    QVariantList args;
    int i = 0;
    foreach(QByteArray typeName,method.parameterTypes())
    {
        int type = QMetaType::type(typeName.constData());

        QVariant arg(type,_a[++i]); // preincrement: start with 1
                                     // (_a[0] is return value)
        args << arg;
    }
    emit mapped(sender(),method,args);
}

最后,其他一些类可以连接映射信号,它将提供发送方对象,信号为QMetaMethod(我们可以从中读取名称),参数为QVariants.

这不是一个完整的解决方案,但最后一步很简单：对于要检查的类的每个信号,我们创建一个GenericSignalMapper,提供信号的元方法.我们将map连接到对象并映射到最终接收器,然后能够处理(并区分)源对象发出的所有信号.

我仍然在将void *参数转换为QVariants时遇到问题.固定. _a还包含索引0处返回值的占位符,因此参数从索引1开始.

例：

在此示例中,“最后一步”(为每个信号创建和连接映射器)是手动完成的.

要检查的班级：

class Test : public QObject
{
    Q_OBJECT
public:
    explicit Test(QObject *parent = 0);

    void emitTestSignal() {
        emit test(1,'x');
    }

signals:
    void test(int,char);
};

最后的处理程序类通过映射器接收所有信号：

class CommonHandler : public QObject
{
    Q_OBJECT
public:
    explicit CommonHandler(QObject *parent = 0);

signals:

public slots:
    void handleSignal(QObject *sender,QVariantList arguments)
    {
        qDebug() << "Signal emitted:";
        qDebug() << "  sender:" << sender;
        qDebug() << "  signal:" << signal.signature();
        qDebug() << "  arguments:" << arguments;
    }
};

我们创建对象并连接它们的代码：

CommonHandler handler;

// In my scenario,it is easy to get the Meta objects since I loop over them.
// Here,4 is the index of SIGNAL(test(int,char))
QMetaMethod signal = Test::staticMetaObject.method(4);

Test test1;
test1.setObjectName("test1");
Test test2;
test2.setObjectName("test2");

GenericSignalMapper mapper1(signal);
QObject::connect(&test1,SIGNAL(test(int,char)),&mapper1,SLOT(map()));
QObject::connect(&mapper1,SIGNAL(mapped(QObject*,QMetaMethod,QVariantList)),&handler,SLOT(handleSignal(QObject*,QVariantList)));

GenericSignalMapper mapper2(signal);
QObject::connect(&test2,&mapper2,SLOT(map()));
QObject::connect(&mapper2,QVariantList)));

test1.emitTestSignal();
test2.emitTestSignal();

输出：

Signal emitted: 
  sender: Test(0xbf955d70,name = "test1") 
  signal: test(int,char) 
  arguments: (QVariant(int,1),QVariant(char,) )  
Signal emitted: 
  sender: Test(0xbf955d68,name = "test2") 
  signal: test(int,) )

(char参数无法正确打印,但它正确存储在QVariant中.其他类型的工作方式就像魅力.)