Question

在包含默认参数的方法上调用QMetaMethod::invoke()时，调用将失败。

class MyClass : public QObject
{
    Q_OBJECT
public:
    Q_INVOKABLE MyClass() : QObject(nullptr){}

public slots:
    int MyMethod(int a = 0)
    {
        return a*2;
    }
};


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

    MyClass* object = new MyClass();
    QMetaObject *metaObject = object->metaObject();

    for(int i=metaObject->methodOffset(); i<metaObject->methodCount(); i++)
    {
        if(metaObject->method(i).name() == "MyMethod")
        {
            int returnVal;

            //returns false
            metaObject->method(i).invoke(object,
                                         Qt::DirectConnection,
                                         Q_RETURN_ARG(int, returnVal));

            break;
        }
    }

    return a.exec();
}

如果我将int作为第一个参数传递，那么它运行良好。有什么方法可以检索该方法的参数的默认值，以便我可以传递这些参数而不是什么都不传递吗？

我正要为每个方法手动将默认值存储在类中，但这是一个丑陋的破解。

感谢您的时间。

Answer 1

如果查看生成的.moc，则会看到以下内容：

void MyClass::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    if (_c == QMetaObject::InvokeMetaMethod) {
        MyClass *_t = static_cast<MyClass *>(_o);
        Q_UNUSED(_t)
        switch (_id) {
        case 0: { int _r = _t->MyMethod((*reinterpret_cast< int(*)>(_a[1])));
            if (_a[0]) *reinterpret_cast< int*>(_a[0]) = std::move(_r); }  break;
        case 1: { int _r = _t->MyMethod();
            if (_a[0]) *reinterpret_cast< int*>(_a[0]) = std::move(_r); }  break;
        default: ;
        }
    }
}

如您所见，生成了2种方法，可以通过打印具有该名称的方法来进行验证：

#include <QCoreApplication>
#include <QMetaMethod>
#include <QDebug>

class MyClass: public QObject
{
    Q_OBJECT
public:
    using QObject::QObject;
public slots:
    int MyMethod(int a = 0){ return a*2;}
};

int main(int argc, char *argv[])
{
    QCoreApplication a(argc, argv);
    MyClass object;
    const QMetaObject *metaObject = object.metaObject();
    for(int i=metaObject->methodOffset(); i<metaObject->methodCount(); i++)
    {
        QMetaMethod method = metaObject->method(i);
        if(method.name() == QByteArray("MyMethod"))
            qDebug()<<i<<method.name();
    };
    return 0;
}

#include "main.moc"

输出：

5 "MyMethod"
6 "MyMethod"

那让他们与众不同的是什么？参数的数量，因此您必须添加一个parameterCount()过滤器。

#include <QCoreApplication>
#include <QMetaMethod>
#include <QDebug>

class MyClass: public QObject
{
    Q_OBJECT
public:
    using QObject::QObject;
public slots:
    int MyMethod(int a = 0){ return a*2;}
};

int main(int argc, char *argv[])
{
    QCoreApplication a(argc, argv);
    MyClass object;
    const QMetaObject *metaObject = object.metaObject();
    for(int i=metaObject->methodOffset(); i<metaObject->methodCount(); i++)
    {
        QMetaMethod method = metaObject->method(i);
        if(method.name() == QByteArray("MyMethod") && method.parameterCount() == 0)
        {
            int returnVal;
            bool status = method.invoke(&object,
                                        Qt::DirectConnection,
                                        Q_RETURN_ARG(int, returnVal));
            Q_ASSERT(status);
            qDebug()<<returnVal;
        }
    };
    return 0;
}

#include "main.moc"

输出：

另一方面，如果您想避免此类问题，可以使用QMetaObject::invokeMethod()进行验证：

MyClass object;
int returnVal;
bool status = QMetaObject::invokeMethod(&object,
                                        "MyMethod",
                                        Qt::DirectConnection,
                                        Q_RETURN_ARG(int, returnVal));
Q_ASSERT(status);
qDebug()<<returnVal;

QMetaMethod :: invoke（）具有参数默认值

1 个答案: