Qt开发：元对象系统的介绍和使用

概述

Qt本身并不是一种编程语言，它实质上是一个跨平台的C++开发类库，是用标准C++编写的类库，它为开发GUI应用程序和非GUI应用程序提供了各种类。Qt对标准C++进行了扩展，引入了一些新的概念和功能，例如信号与槽、对象属性等。Qt的元对象编译器（Meta-Object Compiler, MOC）是一个预处理器，在源程序被编译前先将这些Qt特性的程序转换为标准C++兼容的形式，然后再由标准C++编译器进行编译。这就是为什么在使用信号与槽机制的类里，必须添加一个Q_OBJECT宏的原因，只有添加了这个宏，moc才能对类里的信号与槽的代码进行预处理。Qt Core模块是Qt类库的核心，所有其他模块都依赖于此模块，如果使用qmake来构建项目，Qt Core模块则是被自动加入的。Qt为C++语言增加的特性就是在Qt Core模块里实现的，这些扩展特性由Qt的元对象系统实现，包括信号与槽机制、属性系统、动态类型转换。

元对象系统的概念和组成

QObject是Qt的元对象系统的基础类，它为对象提供了信号与槽机制、对象树、事件处理等功能。QMetaObject是描述类元信息的对象，用于存储类的元数据，包括类名、信号、槽、属性、方法等。每个继承QObject的类都隐式包含一个静态的QMetaObject。另外QMetaProperty表示类的属性，可以通过它动态访问对象的属性。QMetaMethod表示类的方法，可以用于动态调用对象的方法。
元对象系统由以下三个基础组成：

1. QObject类是所有使用元对象系统的类的基类。
2. 在一个类的private部分声明Q_OBJECT宏，使得类可以使用元对象的特性，如动态属性、信号与槽。
3. MOC（元对象编译器）为每个QObject的子类提供必要的代码来实现元对象系统的特性。构建项目时，MOC工具读取C++源文件，当它发现类的定义里有Q_OBJECT宏时，它就会为这个类生成另一个包含有元对象支持代码的C++源文件，这个生成的源文件连同类的实现文件一起被编译和链接。

QObject 的详细介绍

QObject 是 Qt 框架中所有对象模型的基础类，几乎所有的 Qt 类（如 QWidget, QTimer, QThread 等）都直接或间接继承自 QObject。它提供了 Qt 元对象系统的核心功能，包括信号与槽机制、动态属性、事件处理、对象树结构等。

1.QObject 的主要特性

信号与槽机制

支持对象间松耦合的通信。
定义信号和槽的方式：用 signals 关键字定义信号；用 slots 关键字或使用任何公开的 public 方法定义槽。
信号与槽机制常用成员函数：

QObject::connect()：连接信号与槽。
QObject::disconnect()：断开信号与槽。
QObject::signalsBlocked()：检查信号是否被阻塞。
QObject::blockSignals()：阻塞或恢复信号。

#include <QObject>
#include <QDebug>class MyObject : public QObject {Q_OBJECTpublic:MyObject(QObject *parent = nullptr) : QObject(parent) {}signals:void mySignal(int value);public slots:void mySlot(int value) {qDebug() << "Slot received value:" << value;}
};int main() {MyObject obj1, obj2;QObject::connect(&obj1, &MyObject::mySignal, &obj2, &MyObject::mySlot);emit obj1.mySignal(42);  // 触发信号return 0;
}

动态属性

QObject 提供了动态属性支持，可以在运行时为对象添加或修改属性。

属性常用成员函数：

QObject::setProperty(const char *name, const QVariant &value)：设置动态属性。
QObject::property(const char *name)：获取动态属性。
QObject::dynamicPropertyNames()：获取所有动态属性的名称。

#include <QObject>
#include <QDebug>int main() {QObject obj;obj.setProperty("dynamicProperty", 123);qDebug() << "Property value:" << obj.property("dynamicProperty").toInt();foreach (const QByteArray &propName, obj.dynamicPropertyNames()) {qDebug() << "Property name:" << propName;}return 0;
}

对象树（Object Trees）

QObject 通过父子关系管理对象生命周期。
一个对象的子对象会在父对象销毁时自动销毁。

对象树管理常用成员函数：

QObject::setParent(QObject *parent)：设置父对象。
QObject::parent()：获取父对象。
QObject::children()：获取子对象列表。

#include <QObject>
#include <QDebug>int main() {QObject parent;QObject child1(&parent);QObject child2(&parent);qDebug() << "Parent has" << parent.children().size() << "children";return 0;
}

事件处理

支持基于事件的编程，提供事件队列和事件分发机制。
通过重载 QObject::event() 或特定事件处理函数（如 mousePressEvent）处理事件。

事件处理常用成员函数：

QObject::event(QEvent *event)：捕获所有事件。
QObject::installEventFilter(QObject *filterObj)：安装事件过滤器。
QObject::eventFilter(QObject *watched, QEvent *event)：实现自定义事件过滤逻辑。

#include <QObject>
#include <QDebug>
#include <QEvent>class MyFilter : public QObject {Q_OBJECTprotected:bool eventFilter(QObject *watched, QEvent *event) override {qDebug() << "Event filtered for" << watched << "Event type:" << event->type();return QObject::eventFilter(watched, event);}
};int main() {QObject obj;MyFilter filter;obj.installEventFilter(&filter);QEvent event(QEvent::User);QCoreApplication::sendEvent(&obj, &event);return 0;
}

2.QMetaObject的主要特性

函数签名

const QMetaObject *QObject::metaObject() const;

返回值：

返回一个指向 QMetaObject 的指针，包含调用对象的元信息。
QMetaObject 包含类的信号、槽、属性、方法和父类等元信息。

QObject::metaObject() 是 Qt 元对象系统的一部分，用于在运行时获取 QObject 对象的元信息。通过它可以访问与类相关的元数据，例如类名、父类信息、信号、槽、属性、方法等。
通常在以下场景中非常有用：

1. 反射与动态调用：获取类的动态信息，调用类的槽或普通方法。
2. 属性访问：获取动态或静态属性。
3. 插件系统：通过元对象动态加载功能模块。

常用功能

通过 metaObject() 返回的元对象，可以调用以下 QMetaObject 的方法来获取类的信息。
获取基本信息：

className()：返回类名。
superClass()：返回父类的 QMetaObject。

#include <QObject>
#include <QDebug>class MyClass : public QObject {Q_OBJECT
};int main() {MyClass obj;const QMetaObject *metaObject = obj.metaObject();qDebug() << "Class name:" << metaObject->className();qDebug() << "Superclass name:" << (metaObject->superClass() ? metaObject->superClass()->className() : "No superclass");return 0;
}

方法信息：

methodCount()：返回类中所有方法的数量。
method()：按索引获取方法的元信息。
indexOfMethod()：通过方法签名获取方法索引。
invokeMethod()：动态调用方法。

#include <QObject>
#include <QDebug>class MyClass : public QObject {Q_OBJECTpublic slots:void mySlot(const QString &text) {qDebug() << "Slot called with text:" << text;}
};int main() {MyClass obj;const QMetaObject *metaObject = obj.metaObject();int methodIndex = metaObject->indexOfMethod("mySlot(QString)");if (methodIndex != -1) {QMetaMethod method = metaObject->method(methodIndex);method.invoke(&obj, Q_ARG(QString, "Hello, Qt!"));}return 0;
}

属性信息：

propertyCount()：返回类中所有属性的数量。
property()：按索引获取属性的元信息。
indexOfProperty()：通过属性名获取属性索引。

#include <QObject>
#include <QDebug>class MyClass : public QObject {Q_OBJECTQ_PROPERTY(int id MEMBER m_id)Q_PROPERTY(QString name MEMBER m_name)public:MyClass(QObject *parent = nullptr) : QObject(parent), m_id(42), m_name("MyClass") {}private:int m_id;QString m_name;
};int main() {MyClass obj;const QMetaObject *metaObject = obj.metaObject();for (int i = 0; i < metaObject->propertyCount(); ++i) {QMetaProperty property = metaObject->property(i);qDebug() << "Property:" << property.name() << "Value:" << obj.property(property.name());}return 0;
}

信号与槽：

indexOfSignal()：通过信号签名获取信号索引。
indexOfSlot()：通过槽签名获取槽索引。

#include <QObject>
#include <QDebug>class MyClass : public QObject {Q_OBJECTsignals:void mySignal();void anotherSignal(int value);public slots:void mySlot() {}void anotherSlot(int value) {}
};int main() {MyClass obj;const QMetaObject *metaObject = obj.metaObject();qDebug() << "Signals:";for (int i = metaObject->methodOffset(); i < metaObject->methodCount(); ++i) {QMetaMethod method = metaObject->method(i);if (method.methodType() == QMetaMethod::Signal) {qDebug() << "Signal:" << method.methodSignature();}}qDebug() << "Slots:";for (int i = metaObject->methodOffset(); i < metaObject->methodCount(); ++i) {QMetaMethod method = metaObject->method(i);if (method.methodType() == QMetaMethod::Slot) {qDebug() << "Slot:" << method.methodSignature();}}return 0;
}

QMetaObject::invokeMethod的介绍
QMetaObject::invokeMethod 是 Qt 的元对象系统提供的一个强大的方法，用于在运行时以动态的方式调用一个 QObject 的成员函数（包括普通方法和槽）。它一般在以下场景非常有用：

1. 动态调用对象的成员函数。
2. 在多线程环境中，通过跨线程调用信号/槽的方式安全地调用对象方法。
3. 不需要在编译时知道方法名称，可以根据字符串动态查找并调用方法。

QMetaObject::invokeMethod 的函数签名：

bool QMetaObject::invokeMethod(QObject *object,const char *member,Qt::ConnectionType type = Qt::AutoConnection,QGenericReturnArgument ret = QGenericReturnArgument(nullptr),QGenericArgument val0 = QGenericArgument(nullptr),QGenericArgument val1 = QGenericArgument(),QGenericArgument val2 = QGenericArgument(),QGenericArgument val3 = QGenericArgument(),QGenericArgument val4 = QGenericArgument(),QGenericArgument val5 = QGenericArgument(),QGenericArgument val6 = QGenericArgument(),QGenericArgument val7 = QGenericArgument(),QGenericArgument val8 = QGenericArgument(),QGenericArgument val9 = QGenericArgument()
);

主要参数说明：

1.object：调用目标对象。
2.member：要调用的函数名（包括槽函数）。
3.type：指定调用方式，通常与线程相关。 常用值： Qt::DirectConnection：直接在当前线程调用。 Qt::QueuedConnection：将调用放入目标线程的事件队列。
Qt::BlockingQueuedConnection：在多线程中阻塞调用线程，直到目标线程完成调用。
Qt::AutoConnection（默认）：根据对象所属线程自动选择。
4.ret：返回值（可选）。
5.val0 到 val9：最多支持 10 个参数，使用 Q_ARG 宏进行包装。

调用无参数函数

#include <QObject>
#include <QDebug>class MyObject : public QObject {Q_OBJECTpublic slots:void mySlot() {qDebug() << "mySlot() called!";}
};int main() {MyObject obj;QMetaObject::invokeMethod(&obj, "mySlot");return 0;
}

调用带参数的函数

#include <QObject>
#include <QDebug>class MyObject : public QObject {Q_OBJECTpublic slots:void mySlot(const QString &text, int value) {qDebug() << "mySlot() called with text:" << text << "and value:" << value;}
};int main() {MyObject obj;QMetaObject::invokeMethod(&obj, "mySlot",Q_ARG(QString, "Hello, Qt!"),Q_ARG(int, 42));return 0;
}

获取返回值

#include <QObject>
#include <QDebug>class MyObject : public QObject {Q_OBJECTpublic:Q_INVOKABLE QString myMethod(const QString &text) {return "Received: " + text;}
};int main() {MyObject obj;QString returnValue;QMetaObject::invokeMethod(&obj, "myMethod",Q_RETURN_ARG(QString, returnValue),Q_ARG(QString, "Invoke Example"));qDebug() << "Return value:" << returnValue;return 0;
}

多线程中的使用
QMetaObject::invokeMethod 的 Qt::QueuedConnection 方式可以在多线程环境下调用槽函数。

#include <QObject>
#include <QThread>
#include <QDebug>class Worker : public QObject {Q_OBJECTpublic slots:void process() {qDebug() << "Worker process() running in thread:" << QThread::currentThread();}
};int main() {Worker worker;QThread workerThread;worker.moveToThread(&workerThread);workerThread.start();QMetaObject::invokeMethod(&worker, "process", Qt::QueuedConnection);workerThread.quit();workerThread.wait();return 0;
}