The QObject 类是所有 Qt 对象的基类。 更多...
注意： 此类的所有函数 可重入 .
注意： 这些函数也是 thread-safe :
| QObject (QObject * parent = Q_NULLPTR) | |
| virtual | ~QObject () |
| bool | blockSignals (bool block ) |
| const QObjectList & | children () const |
| QMetaObject::Connection | connect (const QObject * sender , const char * signal , const char * method , Qt::ConnectionType type = Qt::AutoConnection) const |
| bool | disconnect (const char * signal = Q_NULLPTR, const QObject * receiver = Q_NULLPTR, const char * method = Q_NULLPTR) const |
| bool | disconnect (const QObject * receiver , const char * method = Q_NULLPTR) const |
| void | dumpObjectInfo () const |
| void | dumpObjectTree () const |
| QList<QByteArray> | dynamicPropertyNames () const |
| virtual bool | event (QEvent * e ) |
| virtual bool | eventFilter (QObject * watched , QEvent * event ) |
| T | findChild (const QString & name = QString(), Qt::FindChildOptions options = Qt::FindChildrenRecursively) const |
| QList<T> | findChildren (const QString & name = QString(), Qt::FindChildOptions options = Qt::FindChildrenRecursively) const |
| QList<T> | findChildren (const QRegExp & regExp , Qt::FindChildOptions options = Qt::FindChildrenRecursively) const |
| QList<T> | findChildren (const QRegularExpression & re , Qt::FindChildOptions options = Qt::FindChildrenRecursively) const |
| bool | inherits (const char * className ) const |
| void | installEventFilter (QObject * filterObj ) |
| bool | isWidgetType () const |
| bool | isWindowType () const |
| void | killTimer (int id ) |
| virtual const QMetaObject * | metaObject () const |
| void | moveToThread (QThread * targetThread ) |
| QString | objectName () const |
| QObject * | parent () const |
| QVariant | property (const char * name ) const |
| void | removeEventFilter (QObject * obj ) |
| void | setObjectName (const QString & name ) |
| void | setParent (QObject * parent ) |
| bool | setProperty (const char * name , const QVariant & value ) |
| bool | signalsBlocked () const |
| int | startTimer (int interval , Qt::TimerType timerType = Qt::CoarseTimer) |
| int | startTimer (std::chrono::milliseconds time , Qt::TimerType timerType = Qt::CoarseTimer) |
| QThread * | thread () const |
| void | deleteLater () |
| void | destroyed (QObject * obj = Q_NULLPTR) |
| void | objectNameChanged (const QString & objectName ) |
| QMetaObject::Connection | connect (const QObject * sender , const char * signal , const QObject * receiver , const char * method , Qt::ConnectionType type = Qt::AutoConnection) |
| QMetaObject::Connection | connect (const QObject * sender , const QMetaMethod & signal , const QObject * receiver , const QMetaMethod & method , Qt::ConnectionType type = Qt::AutoConnection) |
| QMetaObject::Connection | connect (const QObject * sender , PointerToMemberFunction signal , const QObject * receiver , PointerToMemberFunction method , Qt::ConnectionType type = Qt::AutoConnection) |
| QMetaObject::Connection | connect (const QObject * sender , PointerToMemberFunction signal , Functor functor ) |
| QMetaObject::Connection | connect (const QObject * sender , PointerToMemberFunction signal , const QObject * context , Functor functor , Qt::ConnectionType type = Qt::AutoConnection) |
| bool | disconnect (const QObject * sender , const char * signal , const QObject * receiver , const char * method ) |
| bool | disconnect (const QObject * sender , const QMetaMethod & signal , const QObject * receiver , const QMetaMethod & method ) |
| bool | disconnect (const QMetaObject::Connection & connection ) |
| bool | disconnect (const QObject * sender , PointerToMemberFunction signal , const QObject * receiver , PointerToMemberFunction method ) |
| const QMetaObject | staticMetaObject |
| QString | tr (const char * sourceText , const char * disambiguation = Q_NULLPTR, int n = -1) |
| virtual void | childEvent (QChildEvent * event ) |
| virtual void | connectNotify (const QMetaMethod & signal ) |
| virtual void | customEvent (QEvent * event ) |
| virtual void | disconnectNotify (const QMetaMethod & signal ) |
| bool | isSignalConnected (const QMetaMethod & signal ) const |
| int | receivers (const char * signal ) const |
| QObject * | sender () const |
| int | senderSignalIndex () const |
| virtual void | timerEvent (QTimerEvent * event ) |
| typedef | QObjectList |
| QList<T> | qFindChildren (const QObject * obj , const QRegExp & regExp ) |
| T | qobject_cast (QObject * object ) |
| QT_NO_NARROWING_CONVERSIONS_IN_CONNECT | |
| Q_CLASSINFO ( Name , Value ) | |
| Q_DISABLE_COPY ( Class ) | |
| Q_EMIT | |
| Q_ENUM ( ... ) | |
| Q_ENUM_NS ( ... ) | |
| Q_FLAG ( ... ) | |
| Q_FLAG_NS ( ... ) | |
| Q_GADGET | |
| Q_INTERFACES ( ... ) | |
| Q_INVOKABLE | |
| Q_OBJECT | |
| Q_PROPERTY ( ... ) | |
| Q_REVISION | |
| Q_SET_OBJECT_NAME ( Object ) | |
| Q_SIGNAL | |
| Q_SIGNALS | |
| Q_SLOT | |
| Q_SLOTS |
The QObject 类是所有 Qt 对象的基类。
QObject 是心脏在 Qt 对象模型 。该模型的中心特征是非常强大的无缝对象通信机制，称为 信号和槽 。可以连接信号到槽采用 connect () 和销毁连接采用 disconnect ()。为避免从不结束通知循环，可以临时阻塞信号采用 blockSignals ()。保护函数 connectNotify () 和 disconnectNotify () 使之可能跟踪连接。
QObject 组织自身按 对象树 。当创建 QObject 采用另一对象作为父级，对象将自动把自身添加到父级的 children () 列表。父级拥有对象的所有权；即：它将在其析构函数中自动删除其子级。可以查找对象通过名称和可选类型，使用 findChild () 或 findChildren ().
每个对象都有 objectName () 且可以找到其类名凭借相应 metaObject () (见 QMetaObject::className ())。可以确定对象的类是否继承另一个类在 QObject 继承层次结构通过使用 inherits () 函数。
当对象被删除时，它发射 destroyed () 信号。可以捕获此信号以避免 QObjects 的悬空引用。
QObjects 可以接收事件透过 event () 和过滤其它对象的事件。见 installEventFilter () 和 eventFilter () 了解细节。方便处理程序 childEvent ()，可以重实现以捕获子级事件。
最后但最重要， QObject 提供 Qt 支持的基本计时器；见 QTimer 了解计时器的高级支持。
预告 Q_OBJECT 宏是强制性的对于实现信号、槽或特性的任何对象而言。还需要运行 元对象编译器 在源文件。强烈推荐使用此宏在所有子类化的 QObject 不管它们是否实际使用信号、槽及特性，由于不这样做可能导致某些函数显露奇怪行为。
所有 Qt 小部件继承 QObject 。方便函数 isWidgetType () 返回对象是否是实际 Widget。它快得多相比 qobject_cast < QWidget *>( obj ) 或 obj -> inherits (" QWidget ").
某些 QObject 函数，如 children ()，返回 QObjectList . QObjectList 是 typedef 对于 QList < QObject *>.
A QObject 实例称拥有 线程亲缘关系 ，或者它 lives 在某个线程中。当 QObject 接收 队列信号 或 张贴事件 ，槽或事件处理程序将运行在对象存活的线程中。
注意： 若 QObject 没有线程倾向性 (也就是说，若 thread () 返回 0)，或者若它存活在没有正运行事件循环的线程中，那么它无法接收队列信号或张贴事件。
默认情况下， QObject 活在创建它的线程中。可以查询对象的线程倾向性使用 thread () 和改变是使用 moveToThread ().
所有 QObject 必须活在如其父级的相同线程内。因此：
注意： A QObject 的成员变量 do not 自动变为其子级。父/子关系的设置必须通过将指针传递给子级的 constructor ，或者通过调用 setParent ()。没有这一步，对象的成员变量会留在旧线程中当 moveToThread () 被调用。
QObject
既没有拷贝构造函数，也没有赋值运算符。这是设计的。而实际上，它们的声明是在
private
区间采用宏
Q_DISABLE_COPY
()。事实上，所有 Qt 类派生自
QObject
(直接或间接) 使用此宏来声明它们的拷贝构造函数和赋值运算符是私有的。找到原因在讨论有关
标识 vs 值
在 Qt
对象模型
页面。
主要后果是应使用指针指向 QObject (或 QObject 子类)，否则可能引诱您使用 QObject 子类作为值。例如，若没有拷贝构造函数，就不可以使用子类化的 QObject 作为值以存储在某种容器类中。必须存储指针。
Qt 元对象系统提供信号/槽自动连接机制介于 QObject 子类及其子级。只要采用合适对象名称定义对象，且槽遵循简单命名约定，就可以在运行时履行此连接通过 QMetaObject::connectSlotsByName () 函数。
uic 生成援引此函数的代码，以使表单小部件之间能够履行自动连接，创建采用 Qt Designer 。更多信息关于使用自动连接采用 Qt Designer 的给出在 在应用程序中使用 Designer UI 文件 章节的 Qt Designer 手册。
从 Qt 4.2 起，可以添加动态特性和移除从 QObject 实例在运行时。编译时不需要声明动态特性，它们仍提供如静态特性的相同优点且操纵是使用相同 API - 使用 property () 读取它们和 setProperty () 以写入它们。
从 Qt 4.3 起，动态特性的支持通过 Qt Designer ，且标准 Qt Widget 和用户创建的表单两者都可以赋予动态特性。
所有 QObject 子类都支持 Qt 翻译特征，使之可能将应用程序用户界面翻译成不同语言。
为使对用户可见的文本可翻译，必须将它包裹在调用 tr () 函数。这的详细解释在 编写翻译源代码 文档。
另请参阅 QMetaObject , QPointer , QObjectCleanupHandler , Q_DISABLE_COPY ()，和 对象树 & 所有权 .
此特性保持该对象的名称
可按名称 (和类型) 查找对象，使用 findChild ()。可找到一组对象采用 findChildren ().
qDebug("MyClass::setPrecision(): (%s) invalid precision %f", qPrintable(objectName()), newPrecision);
默认情况下，此特性包含空字符串。
访问函数：
| QString | objectName () const |
| void | setObjectName (const QString & name ) |
通知程序信号：
| void | objectNameChanged (const QString & objectName ) | [见下文注意事项] |
注意： 这是私有信号。它可以用于信号连接，但不能由用户发射。
另请参阅 metaObject () 和 QMetaObject::className ().
构造对象采用父级对象 parent .
对象的父级可以被视为对象的所有者。例如， 对话框 是父级对于 OK and Cancel 按钮 (它包含的)。
父级对象的析构函数会销毁所有子级对象。
设置 parent 为 0 构造没有父级的对象。若对象是 Widget，它将变为顶层窗口。
另请参阅 parent (), findChild ()，和 findChildren ().
[虚拟]
QObject::
~QObject
()
销毁对象，删除其所有子级对象。
自动断开到/自对象的所有信号连接，并从事件队列移除对象的任何待决张贴事件。不管怎样，经常更安全使用 deleteLater () 而不是删除 QObject 子类直接。
警告： 删除所有子级对象。若这些对象中的任一在堆栈 (或全局) 中，程序迟早会崩溃。不推荐从父级外部保持子级对象的指针。若仍然这样做， destroyed () 信号给予机会以检测对象何时被销毁。
警告： 删除 QObject 当等待交付的待决事件会导致崩溃时。不得删除 QObject 直接，若它存在于目前执行线程的不同线程中。使用 deleteLater () 代替，将导致事件循环删除对象在所有待决事件被交付给对象之后。
另请参阅 deleteLater ().
若 block 为 true，阻塞由此对象发射的信号 (即：发射信号不会援引与其连接的任何东西)。若 block 为 false，不会发生这种阻塞。
返回值是先前值的 signalsBlocked ().
注意， destroyed () 信号会被发射，即使此对象的信号已被阻塞。
当被阻塞时发出的信号，不会被缓冲。
另请参阅 signalsBlocked () 和 QSignalBlocker .
[virtual protected]
void
QObject::
childEvent
(
QChildEvent
*
event
)
可以在子类中重实现此事件处理程序以接收子级事件。事件被传入 event 参数。
QEvent::ChildAdded
and
QEvent::ChildRemoved
事件被发送给对象，当添加或移除子级时。在这 2 种情况下，只能依赖的子级是
QObject
，或者若
isWidgetType
() 返回
true
，
QWidget
。(这是因为，在
ChildAdded
情况下，子级尚未被完全构造，而在
ChildRemoved
情况下，它可能已经被销毁)。
QEvent::ChildPolished 事件被发送给 Widget 当子级被抛光时，或者当添加抛光子级时。若收到子级抛光事件，子级的构造通常已完成。不管怎样，这不保证，且在 Widget 构造函数执行期间可能交付多个抛光事件。
对于每个子级 Widget，接收一个 ChildAdded 事件，零个或多个 ChildPolished 事件，和一个 ChildRemoved 事件。
The ChildPolished 事件被省略若子级立即被移除在被添加之后。若子级在构建和销毁期间中被多次抛光，则可能收到同一子级的几个子级抛光事件，每次采用不同虚拟表格。
另请参阅 event ().
返回子级对象的列表。
QObjectList
类的定义在
<QObject>
头文件，如下所示：
typedef QList<QObject*> QObjectList;
第一添加子级是 first 对象在列表中，且最后添加子级是 last 对象在列表中，即：新子级被追加在末尾。
注意：列表次序改变，当 QWidget 子级 raised or lowered 。被提升 Widget 变为最后列表对象，被降低 Widget 变为第一列表对象。
另请参阅 findChild (), findChildren (), parent ()，和 setParent ().
[static]
QMetaObject::Connection
QObject::
connect
(const
QObject
*
sender
, const
char
*
signal
, const
QObject
*
receiver
, const
char
*
method
,
Qt::ConnectionType
type
= Qt::AutoConnection)
创建连接为给定 type 从 signal 在 sender 对象到 method 在 receiver 对象。返回可用于稍后断开连接的连接句柄。
必须使用
SIGNAL()
and
SLOT()
宏当指定
signal
和
method
，例如：
QLabel *label = new QLabel; QScrollBar *scrollBar = new QScrollBar; QObject::connect(scrollBar, SIGNAL(valueChanged(int)), label, SLOT(setNum(int)));
此范例确保标签始终显示当前滚动条值。注意，信号和槽参数不得包含任何变量名，只能包含类型。如，以下将不工作且返回 false:
// WRONG QObject::connect(scrollBar, SIGNAL(valueChanged(int value)), label, SLOT(setNum(int value)));
也可以将信号连接到另一信号:
class MyWidget : public QWidget { Q_OBJECT public: MyWidget(); signals: void buttonClicked(); private: QPushButton *myButton; }; MyWidget::MyWidget() { myButton = new QPushButton(this); connect(myButton, SIGNAL(clicked()), this, SIGNAL(buttonClicked())); }
在此范例中，
MyWidget
构造函数中继来自私有成员变量的信号，并使它可用当名称相关
MyWidget
.
信号可以连接到多个槽和信号。多个信号可以连接到一个槽。
若信号连接到几个槽，当发射信号时，这些槽按制作连接的相同次序被激活。
函数返回 QMetaObject::Connection 表示要连接的句柄，若成功将信号连接到槽。连接句柄将是无效的若它无法创建连接，例如，若 QObject 无法验证存在 signal or method ，或若它们的签名不兼容。可以校验句柄是否有效，通过将它铸造成布尔。
默认情况下，制作的每个连接都会发出信号；重复连接发射 2 个信号。可以断开所有这些连接采用一个 disconnect () 调用。若传递 Qt::UniqueConnection type ，只在不重复时才制作连接。若已经重复 (准确相同的信号到同一对象中准确相同的槽)，连接将失败且连接会返回无效 QMetaObject::Connection .
注意： Qt::UniqueConnections 不工作于 Lambda、非成员函数及函子；它们仅适用于连接到成员函数。
可选 type 参数描述要建立的连接类型。尤其，它确定特定信号是立即交付给槽，还是稍后排队交付。若信号排队，参数必须是 Qt 元对象系统已知类型，因为 Qt 需要拷贝自变量以将它们存储在幕后事件中。若试着使用排队连接且获得错误消息
QObject::connect: Cannot queue arguments of type 'MyType' (Make sure 'MyType' is registered using qRegisterMetaType().)
call qRegisterMetaType () 以注册数据类型在建立连接之前。
注意： 此函数是 thread-safe .
另请参阅 disconnect (), sender (), qRegisterMetaType (), Q_DECLARE_METATYPE ()，和 基于字符串的连接和基于函子的连接之间的差异 .
[static]
QMetaObject::Connection
QObject::
connect
(const
QObject
*
sender
, const
QMetaMethod
&
signal
, const
QObject
*
receiver
, const
QMetaMethod
&
method
,
Qt::ConnectionType
type
= Qt::AutoConnection)
创建连接为给定 type 从 signal 在 sender 对象到 method 在 receiver 对象。返回可用于稍后断开连接的连接句柄。
连接句柄将是无效的 (例如：参数无效)，若它不能创建连接。可以校验若 QMetaObject::Connection 有效，通过将它铸造成布尔。
此函数的工作方式相同如
connect(const QObject *sender, const char *signal, const QObject *receiver, const char *method, Qt::ConnectionType type)
但它使用
QMetaMethod
来指定信号和方法。
该函数在 Qt 4.8 引入。
另请参阅 connect (const QObject *sender, const char *signal, const QObject *receiver, const char *method, Qt::ConnectionType type).
此函数重载 connect ().
连接 signal 从 sender 对象到此对象的 method .
相当于 connect(
sender
,
signal
,
this
,
method
,
type
).
每个建立连接都会发射信号，因此重复连接会发射 2 个信号。可以断开连接使用 disconnect ().
注意： 此函数是 thread-safe .
另请参阅 disconnect ().
[static]
QMetaObject::Connection
QObject::
connect
(const
QObject
*
sender
,
PointerToMemberFunction
signal
, const
QObject
*
receiver
,
PointerToMemberFunction
method
,
Qt::ConnectionType
type
= Qt::AutoConnection)
此函数重载 connect ().
创建连接为给定 type 从 signal 在 sender 对象到 method 在 receiver 对象。返回可用于稍后断开连接的连接句柄。
信号必须是在 Header (头) 中声明作为信号的函数。槽函数可以是能连接到信号的任何成员函数。槽可以连接到给定信号，若信号拥有至少如槽一样多的自变量，且信号和槽中的相应自变量类型之间存在隐式转换。
范例：
QLabel *label = new QLabel; QLineEdit *lineEdit = new QLineEdit; QObject::connect(lineEdit, &QLineEdit::textChanged, label, &QLabel::setText);
此范例确保标签始终显示当前行编辑文本。
信号可以连接到多个槽和信号。多个信号可以连接到一个槽。
若信号被连接到几个槽，这些槽将按制作连接的相同次序被激活，当发射信号时
函数返回连接句柄，若它将信号成功连接到槽。连接句柄将是无效的，若它不能创建连接，例如，若 QObject 无法验证是否存在 signal (若它未被声明成信号) 可以校验若 QMetaObject::Connection 有效，通过将它铸造成布尔。
默认情况下，制作的每个连接都会发出信号；重复连接发射 2 个信号。可以断开所有这些连接采用一个 disconnect () 调用。若传递 Qt::UniqueConnection type ，只在不重复时才制作连接。若已经重复 (准确相同的信号到同一对象中准确相同的槽)，连接将失败且连接会返回无效 QMetaObject::Connection .
可选 type 参数描述要建立的连接类型。尤其，它确定特定信号是立即交付给槽，还是稍后排队交付。若信号排队，参数必须是 Qt 元对象系统已知类型，因为 Qt 需要拷贝自变量以将它们存储在幕后事件中。若试着使用排队连接且获得错误消息
QObject::connect: Cannot queue arguments of type 'MyType' (Make sure 'MyType' is registered using qRegisterMetaType().)
确保声明自变量类型采用 Q_DECLARE_METATYPE
重载函数可以解析借助 qOverload .
注意： 此函数是 thread-safe .
另请参阅 基于字符串的连接和基于函子的连接之间的差异 .
[static]
QMetaObject::Connection
QObject::
connect
(const
QObject
*
sender
,
PointerToMemberFunction
signal
,
Functor
functor
)
此函数重载 connect ().
创建连接从 signal in sender 对象到 functor ，并返回要连接的句柄
信号必须是在头中被声明为信号的函数。槽函数是可以连接到信号的任何函数 (或函子)。函数可以连接到给定信号，若信号至少如槽一样多自变量。函子可以连接到信号，若它们拥有的自变量数量准确相同。在信号和槽中的相应自变量类型之间，必须存在隐式转换。
范例：
void someFunction(); QPushButton *button = new QPushButton; QObject::connect(button, &QPushButton::clicked, someFunction);
也可以使用 Lambda 表达式：
QByteArray page = ...; QTcpSocket *socket = new QTcpSocket; socket->connectToHost("qt-project.org", 80); QObject::connect(socket, &QTcpSocket::connected, [=] () { socket->write("GET " + page + "\r\n"); });
连接将自动断开，若发送者被销毁。不管怎样，应小心在函子中使用的任何对象仍存活，当发射信号时。
重载函数可以解析借助 qOverload .
注意： 此函数是 thread-safe .
[static]
QMetaObject::Connection
QObject::
connect
(const
QObject
*
sender
,
PointerToMemberFunction
signal
, const
QObject
*
context
,
Functor
functor
,
Qt::ConnectionType
type
= Qt::AutoConnection)
此函数重载 connect ().
创建连接按给定 type from signal in sender 对象到 functor 以放置在特定事件循环 context ，并返回要连接的句柄。
注意： Qt::UniqueConnections 不工作于 Lambda、非成员函数及函子；它们仅适用于连接到成员函数。
信号必须是在头中被声明为信号的函数。槽函数是可以连接到信号的任何函数 (或函子)。函数可以连接到给定信号，若信号至少如槽一样多自变量。函子可以连接到信号，若它们拥有的自变量数量准确相同。在信号和槽中的相应自变量类型之间，必须存在隐式转换。
范例：
void someFunction(); QPushButton *button = new QPushButton; QObject::connect(button, &QPushButton::clicked, this, someFunction, Qt::QueuedConnection);
也可以使用 Lambda 表达式：
QByteArray page = ...; QTcpSocket *socket = new QTcpSocket; socket->connectToHost("qt-project.org", 80); QObject::connect(socket, &QTcpSocket::connected, this, [=] () { socket->write("GET " + page + "\r\n"); }, Qt::AutoConnection);
连接将自动断开，若发送者 (或上下文) 被销毁。不管怎样，应小心在函子中使用的任何对象仍存活，当发射信号时。
重载函数可以解析借助 qOverload .
注意： 此函数是 thread-safe .
该函数在 Qt 5.2 引入。
[virtual protected]
void
QObject::
connectNotify
(const
QMetaMethod
&
signal
)
此虚函数被调用当某些东西已连接到 signal 在此对象。
若想要比较 signal 采用特定信号，可以使用 QMetaMethod::fromSignal () 如下：
if (signal == QMetaMethod::fromSignal(&MyObject::valueChanged)) { // signal is valueChanged }
警告： 此函数违反了面向对象的模块化原则。不管怎样，它可能很有用仅当某些东西连接到信号时，才需要履行昂贵的初始化。
警告： 此函数被履行连接的线程所调用，该线程可能不同于此对象存活的线程。
该函数在 Qt 5.0 引入。
另请参阅 connect () 和 disconnectNotify ().
[virtual protected]
void
QObject::
customEvent
(
QEvent
*
event
)
可以在子类中重实现此事件处理程序，以接收自定义事件。自定义事件是用户定义事件，具有类型值至少一样大如 QEvent::User 项的 QEvent::Type 枚举, 且通常是 QEvent 子类。事件被传入 event 参数。
[slot]
void
QObject::
deleteLater
()
调度删除此对象。
将删除对象，当控制返回给事件循环时。若事件循环未运行，当调用此函数时 (如，对象调用 deleteLater() 先于 QCoreApplication::exec ())，会删除对象，一旦启动事件循环。若在 main 事件循环已停止后调用 deleteLater()，就不会删除对象。从 Qt 4.8 起，若活在未运行事件循环线程中的对象调用 deleteLater()，就不会销毁对象当线程完成时。
注意：进入和离开新事件循环 (如，通过打开模态对话框) 会 not 履行延迟删除；对于要删除对象，控制必须返回给调用 deleteLater() 的事件循环。
注意： 多次调用此函数是安全的；当交付首个延迟删除事件时，会从事件队列移除对象的任何待决事件。
另请参阅 destroyed () 和 QPointer .
[signal]
void
QObject::
destroyed
(
QObject
*
obj
= Q_NULLPTR)
此信号立即发射先于对象 obj 被销毁，且不阻塞。
立即销毁所有对象的子级，在此信号被发射之后。
另请参阅 deleteLater () 和 QPointer .
[static]
bool
QObject::
disconnect
(const
QObject
*
sender
, const
char
*
signal
, const
QObject
*
receiver
, const
char
*
method
)
断开连接
signal
在对象
sender
from
method
在对象
receiver
。返回
true
若连接被成功中断；否则返回
false
.
信号/槽连接被移除，当涉及的对象被销毁时。
disconnect() 通常按以下范例演示的 3 种方式使用。
disconnect(myObject, 0, 0, 0);
相当于非静态重载函数
myObject->disconnect();
disconnect(myObject, SIGNAL(mySignal()), 0, 0);
相当于非静态重载函数
myObject->disconnect(SIGNAL(mySignal()));
disconnect(myObject, 0, myReceiver, 0);
相当于非静态重载函数
myObject->disconnect(myReceiver);
0 可以用作通配符，分别意味着任何信号、任何接收对象、或在接收对象中的任何槽。
The sender 可以从不为 0 (无法在信号调用中断开来自多个对象的信号)。
若 signal 为 0，它断开连接 receiver and method 从任何信号。若没有，仅断开连接指定信号。
若 receiver 为 0，它断开连接任何东西连接到 signal 。若不，对象中的槽除了 receiver 不被断开连接。
若 method 为 0，它断开连接任何东西连接到 receiver 。若不，仅槽称为 method 会被断开连接，且单独剩下所有其它槽。 method 必须为 0 若 receiver 被省略，所以无法断开连接所有对象中的具体命名槽。
注意： 此函数是 thread-safe .
另请参阅 connect ().
[static]
bool
QObject::
disconnect
(const
QObject
*
sender
, const
QMetaMethod
&
signal
, const
QObject
*
receiver
, const
QMetaMethod
&
method
)
断开连接
signal
在对象
sender
from
method
在对象
receiver
。返回
true
若连接被成功中断；否则返回
false
.
此函数提供相同可能性，像
disconnect(const QObject *sender, const char *signal, const QObject *receiver, const char *method)
但使用
QMetaMethod
来表示要断开的信号和方法。
Additionally this function returnsfalse and no signals and slots disconnected if:
QMetaMethod() 可以用作通配符，意味着任何信号、或在接收对象中的任何槽。以相同方式，0 可以用于 receiver 意味着任何接收对象。在此情况下，方法也应该是 QMetaMethod()。 sender 参数从不应该为 0。
该函数在 Qt 4.8 引入。
另请参阅 disconnect (const QObject *sender, const char *signal, const QObject *receiver, const char *method).
此函数重载 disconnect ().
断开连接 signal from method of receiver .
信号/槽连接被移除，当涉及的对象被销毁时。
注意： 此函数是 thread-safe .
此函数重载 disconnect ().
断开连接此对象的所有信号从 receiver 's method .
信号/槽连接被移除，当涉及的对象被销毁时。
[static]
bool
QObject::
disconnect
(const
QMetaObject::Connection
&
connection
)
断开连接的连接。
若 connection 无效或已断开连接，什么都不做并返回 false。
另请参阅 connect ().
[static]
bool
QObject::
disconnect
(const
QObject
*
sender
,
PointerToMemberFunction
signal
, const
QObject
*
receiver
,
PointerToMemberFunction
method
)
此函数重载 diconnect()。
断开连接
signal
在对象
sender
from
method
在对象
receiver
。返回
true
若连接被成功中断；否则返回
false
.
信号/槽连接被移除，当涉及的对象被销毁时。
disconnect () 通常按以下范例演示的 3 种方式使用。
disconnect(myObject, 0, 0, 0);
disconnect(myObject, &MyObject::mySignal(), 0, 0);
disconnect(myObject, 0, myReceiver, 0);
QObject::disconnect(lineEdit, &QLineEdit::textChanged, label, &QLabel::setText);
0 可以用作通配符，分别意味着任何信号、任何接收对象、或在接收对象中的任何槽。
The sender 可以从不为 0 (无法在信号调用中断开来自多个对象的信号)。
若 signal 为 0，它断开连接 receiver and method 从任何信号。若没有，仅断开连接指定信号。
若 receiver 为 0，它断开连接任何东西连接到 signal 。若不，对象中的槽除了 receiver 不被断开连接。
若 method 为 0，它断开连接任何东西连接到 receiver 。若不，仅槽称为 method 会被断开连接，且单独剩下所有其它槽。 method 必须为 0 若 receiver 被省略，所以无法断开连接所有对象中的具体命名槽。
注意： 使用此重载断开连接连接到函子 (或 Lambda 表达式) 的信号，是不可能的。这是因为不可能比较它们。取而代之，使用重载接受 QMetaObject::Connection
注意： 此函数是 thread-safe .
另请参阅 connect ().
[virtual protected]
void
QObject::
disconnectNotify
(const
QMetaMethod
&
signal
)
此虚函数被调用当某些东西已断开连接从 signal 在此对象。
见 connectNotify () 例如如何比较 signal 采用特定信号。
若所有信号与此对象断开连接 (如：信号自变量的
disconnect
() 为 0)，disconnectNotify() 只被调用一次，且
signal
将是无效
QMetaMethod
(
QMetaMethod::isValid
() 返回
false
).
警告： 此函数违反了面向对象的模块化原则。不管怎样，它可能很有用为优化昂贵资源的访问。
警告： 从履行断开连接的线程调用此函数，线程可能是异于此对象存活线程的不同线程。还可以调用此函数采用 QObject 内部互斥锁定。因此，不允许重新进入任何 QObject 函数从重实现，且若在重实现中锁定互斥，确保不要调用 QObject 函数采用在其它地方保持互斥，否则将导致死锁。
该函数在 Qt 5.0 引入。
另请参阅 disconnect () 和 connectNotify ().
将有关此对象的信号连接等信息转储到调试输出。
注意： 在 Qt 5.9 之前，此函数不是 const。
另请参阅 dumpObjectTree ().
将子级树转储到调试输出。
注意： 在 Qt 5.9 之前，此函数不是 const。
另请参阅 dumpObjectInfo ().
返回被动态添加到对象的所有特性的名称，使用 setProperty ().
该函数在 Qt 4.2 引入。
[虚拟]
bool
QObject::
event
(
QEvent
*
e
)
此虚函数接收对象事件并返回 true，若事件 e 被识别并处理。
event() 函数可以被重实现，以定制对象行为。
确保调用父级事件类实现，为所有未处理事件。
范例：
class MyClass : public QWidget { Q_OBJECT public: MyClass(QWidget *parent = 0); ~MyClass(); bool event(QEvent* ev) { if (ev->type() == QEvent::PolishRequest) { // overwrite handling of PolishRequest if any doThings(); return true; } else if (ev->type() == QEvent::Show) { // complement handling of Show if any doThings2(); QWidget::event(ev); return true; } // Make sure the rest of events are handled return QWidget::event(ev); } };
另请参阅 installEventFilter (), timerEvent (), QCoreApplication::sendEvent ()，和 QCoreApplication::postEvent ().
[虚拟]
bool
QObject::
eventFilter
(
QObject
*
watched
,
QEvent
*
event
)
过滤事件，若已将此对象安装成事件过滤器对于 watched 对象。
在此函数的重实现中，若希望过滤 event 即：停止进一步处理，返回 true；否则返回 false。
范例：
class MainWindow : public QMainWindow { public: MainWindow(); protected: bool eventFilter(QObject *obj, QEvent *ev); private: QTextEdit *textEdit; }; MainWindow::MainWindow() { textEdit = new QTextEdit; setCentralWidget(textEdit); textEdit->installEventFilter(this); } bool MainWindow::eventFilter(QObject *obj, QEvent *event) { if (obj == textEdit) { if (event->type() == QEvent::KeyPress) { QKeyEvent *keyEvent = static_cast<QKeyEvent*>(event); qDebug() << "Ate key press" << keyEvent->key(); return true; } else { return false; } } else { // pass the event on to the parent class return QMainWindow::eventFilter(obj, event); } }
注意：在以上范例中，未处理事件被传递给基类的 eventFilter() 函数，由于基类可能出于自已的内部目的有重实现 eventFilter()。
警告： 若在此函数中删除接收者对象，确保返回 true。否则，Qt 将把事件转发给被删除对象，且程序可能崩溃。
另请参阅 installEventFilter ().
返回此对象的子级可以被铸造成 T 类型且被称为 name ，或 0 若没有这种对象。省略 name 自变量导致匹配所有对象名称。搜索是递归履行的，除非 options 指定 FindDirectChildrenOnly 选项。
若有多个子级匹配搜索，返回最直接祖先。若有多个直接祖先，返回哪个未定义。在此情况下， findChildren () 应该被使用。
此范例返回子级
QPushButton
of
parentWidget
命名
"button1"
，即使按钮不是父级的直接子级：
QPushButton *button = parentWidget->findChild<QPushButton *>("button1");
此范例返回
QListWidget
子级对于
parentWidget
:
QListWidget *list = parentWidget->findChild<QListWidget *>();
此范例返回子级
QPushButton
of
parentWidget
(其直接父级) 命名
"button1"
:
QPushButton *button = parentWidget->findChild<QPushButton *>("button1", Qt::FindDirectChildrenOnly);
此范例返回
QListWidget
子级对于
parentWidget
，其直接父级：
QListWidget *list = parentWidget->findChild<QListWidget *>(QString(), Qt::FindDirectChildrenOnly);
另请参阅 findChildren ().
返回此对象的所有子级具有给定 name 可以被铸造成 T 类型，或空列表若没有这种对象。省略 name 自变量导致匹配所有对象名称。搜索是递归履行的，除非 options 指定 FindDirectChildrenOnly 选项。
以下范例展示如何查找列表化的子级
QWidget
为指定
parentWidget
命名
widgetname
:
QList<QWidget *> widgets = parentWidget.findChildren<QWidget *>("widgetname");
此范例返回所有
QPushButton
其是子级对于
parentWidget
:
QList<QPushButton *> allPButtons = parentWidget.findChildren<QPushButton *>();
此范例返回所有
QPushButton
其是直系子级对于
parentWidget
:
QList<QPushButton *> childButtons = parentWidget.findChildren<QPushButton *>(QString(), Qt::FindDirectChildrenOnly);
另请参阅 findChild ().
此函数重载 findChildren ().
返回此对象的子级，可以被铸造成 T 类型且拥有的名称匹配正则表达式 regExp ，或空列表若没有这种对象。递归履行搜索，除非 options 指定 FindDirectChildrenOnly 选项。
此函数重载 findChildren ().
返回此对象的子级，可以被铸造成 T 类型且拥有的名称匹配正则表达式 re ，或空列表若没有这种对象。递归履行搜索，除非 options 指定 FindDirectChildrenOnly 选项。
该函数在 Qt 5.0 引入。
返回
true
若此对象是类实例，继承
className
或
QObject
子类，继承
className
；否则返回
false
.
类被认为继承本身。
范例：
QTimer *timer = new QTimer; // QTimer inherits QObject timer->inherits("QTimer"); // returns true timer->inherits("QObject"); // returns true timer->inherits("QAbstractButton"); // returns false // QVBoxLayout inherits QObject and QLayoutItem QVBoxLayout *layout = new QVBoxLayout; layout->inherits("QObject"); // returns true layout->inherits("QLayoutItem"); // returns true (even though QLayoutItem is not a QObject)
若为铸造目的需要确定对象是否为特定类的实例，考虑使用 qobject_cast <Type *>(object) 代替。
另请参阅 metaObject () 和 qobject_cast ().
安装事件过滤器 filterObj 在此对象。例如：
monitoredObj->installEventFilter(filterObj);
事件过滤器是接收发送给此对象的所有事件的对象。过滤器可以停止事件 (或将其转发给此对象)。事件过滤器 filterObj 接收事件凭借其 eventFilter () 函数。 eventFilter () 函数必须返回 true，若事件应该被过滤 (即：停止)；否则，它必须返回 false。
若在单个对象安装多个事件过滤器，将首先激活最后安装的过滤器。
这里是
KeyPressEater
类，会吃掉其监控对象的键按下：
class KeyPressEater : public QObject { Q_OBJECT ... protected: bool eventFilter(QObject *obj, QEvent *event); }; bool KeyPressEater::eventFilter(QObject *obj, QEvent *event) { if (event->type() == QEvent::KeyPress) { QKeyEvent *keyEvent = static_cast<QKeyEvent *>(event); qDebug("Ate key press %d", keyEvent->key()); return true; } else { // standard event processing return QObject::eventFilter(obj, event); } }
和这里是如何将其安装在 2 小部件中：
KeyPressEater *keyPressEater = new KeyPressEater(this); QPushButton *pushButton = new QPushButton(this); QListView *listView = new QListView(this); pushButton->installEventFilter(keyPressEater); listView->installEventFilter(keyPressEater);
The QShortcut 类，例如，使用此技术来拦截快捷键按下。
警告： 若删除接收者对象在 eventFilter () 函数，确保返回 true。若返回 false，Qt 把事件发送给已删除对象，且程序会崩溃。
注意，过滤对象必须与此对象在同一线程中。若 filterObj 在不同线程中, 此函数什么都不做。若 filterObj 或在调用此函数后此对象被移入不同线程，不会调用事件过滤器直到 2 对象再次拥有相同线程亲缘关系 (它 not 被移除)。
另请参阅 removeEventFilter (), eventFilter ()，和 event ().
[protected]
bool
QObject::
isSignalConnected
(const
QMetaMethod
&
signal
) const
返回
true
若
signal
连接至少一接收者，否则返回
false
.
signal 必须是此对象的信号成员，否则行为未定义。
static const QMetaMethod valueChangedSignal = QMetaMethod::fromSignal(&MyObject::valueChanged); if (isSignalConnected(valueChangedSignal)) { QByteArray data; data = get_the_value(); // expensive operation emit valueChanged(data); }
如以上代码片段阐明，可以使用此函数以避免发射无人监听的信号。
警告： 此函数违反了面向对象的模块化原则。不管怎样，它可能很有用仅当某些东西连接到信号时，才需要履行昂贵的初始化。
该函数在 Qt 5.0 引入。
返回
true
若对象是 Widget；否则返回
false
.
调用此函数相当于调用
inherits("QWidget")
，除了它更快。
返回
true
若对象是窗口；否则返回
false
.
调用此函数相当于调用
inherits("QWindow")
，除了它更快。
杀除计时器采用计时器标识符， id .
计时器标识符被返回通过 startTimer () 当计时器事件被启动时。
另请参阅 timerEvent () 和 startTimer ().
[虚拟]
const
QMetaObject
*QObject::
metaObject
() const
返回此对象的元对象指针。
元对象包含的信息有关类继承 QObject ，如类名、超类名称、特性、信号和槽。每个 QObject 子类包含 Q_OBJECT 宏将拥有元对象。
元对象信息是信号/槽连接机制和特性系统要求的。 inherits () 函数还利用了元对象。
若没有指向实际对象实例的指针但仍想访问类的元对象，可以使用 staticMetaObject .
范例：
QObject *obj = new QPushButton; obj->metaObject()->className(); // returns "QPushButton" QPushButton::staticMetaObject.className(); // returns "QPushButton"
另请参阅 staticMetaObject .
更改此对象及其子级的线程亲缘关系。对象无法被移动，若它有父级。事件处理将继续在 targetThread .
要将对象移至主线程，使用 QApplication::instance () 检索指向当前应用程序的指针，然后使用 QApplication::thread () 来检索应用程序在其中存活的线程。例如：
myObject->moveToThread(QApplication::instance()->thread());
若 targetThread 为 0， 停止此对象及其子级的所有事件处理。
注意，对象的所有活动计时器都将被重置。计时器先在当前线程中停止并重启 (采用相同间隔) 在 targetThread 。因此，在线程之间不断移动对象可以无限期推迟计时器事件。
A QEvent::ThreadChange 事件被发送给此对象，恰好在改变线程亲缘关系之前。可以处理此事件以履行任何特殊处理。注意，张贴给此对象的任何新事件都将被处理在 targetThread .
警告： 此函数是 not 线程安全的；当前线程必须与当前线程亲缘关系相同。换句话说，此函数只可以把对象从当前线程 "压入" 到另一线程，它不可以从任意线程 "拉出" 对象到当前线程。
另请参阅 thread ().
[signal]
void
QObject::
objectNameChanged
(const
QString
&
objectName
)
此信号发射，在对象名称改变后。传递新对象名称按 objectName .
注意： 这是私有信号。它可以用于信号连接，但不能由用户发射。
注意： 通知程序信号对于特性 objectName .
另请参阅 QObject::objectName .
返回指向父级对象的指针。
另请参阅 setParent () 和 children ().
返回值为对象的 name 特性。
若不存在这种特性，则返回的变体是无效的。
所有可用特性的有关信息，提供透过 metaObject () 和 dynamicPropertyNames ().
另请参阅 setProperty (), QVariant::isValid (), metaObject ()，和 dynamicPropertyNames ().
[protected]
int
QObject::
receivers
(const
char
*
signal
) const
返回接收者数为连接到 signal .
由于槽和信号两者可以用作信号的接收者，且可以多次建立相同连接，接收者数与从此信号建立的连接数相同。
当调用此函数时，可以使用
SIGNAL()
宏来传递特定信号：
if (receivers(SIGNAL(valueChanged(QByteArray))) > 0) { QByteArray data; get_the_value(&data); // expensive operation emit valueChanged(data); }
警告： 此函数违反了面向对象的模块化原则。不管怎样，它可能很有用仅当某些东西连接到信号时，才需要履行昂贵的初始化。
另请参阅 isSignalConnected ().
移除事件过滤器对象 obj 从此对象。忽略请求，若尚未安装这种事件过滤器。
将自动移除此对象的所有事件过滤器，当此对象被销毁时。
它始终安全地移除事件过滤器，即使在事件过滤器激活期间 (即：从 eventFilter () 函数)。
另请参阅 installEventFilter (), eventFilter ()，和 event ().
[protected]
QObject
*QObject::
sender
() const
返回指向发送信号的对象的指针，若在由信号激活的槽中被调用；否则它返回 0。指针在从此对象的线程上下文调用此函数的槽执行期间才有效。
由此函数返回的指针变为无效若发送者被销毁，或者，若槽断开连接发送者信号。
警告： 此函数违反了面向对象的模块化原则。不管怎样，访问发送者可能很有用，当多个信号连接到单个槽时。
警告： 如上所述，此函数的返回值无效，当槽被调用凭借 Qt::DirectConnection 来自不同于此对象线程的线程。不要在这种情景类型下使用此函数。
另请参阅 senderSignalIndex () 和 QSignalMapper .
[protected]
int
QObject::
senderSignalIndex
() const
返回目前调用执行槽的信号的元方法索引，它是类成员返回通过 sender ()。若在由信号激活的槽外调用，返回 -1。
对于具有默认参数的信号，此函数总是返回带有所有参数的索引，不管如何使用采用
connect
()。例如，信号
destroyed(QObject *obj = 0)
将有 2 个不同索引 (带和不带参数)，但此函数总是返回带参数的索引。这不适用，当以不同参数重载信号时。
警告： 此函数违反了面向对象的模块化原则。不管怎样，访问信号索引可能很有用，当多个信号连接到单个槽时。
警告： 此函数的返回值无效，当槽被调用凭借 Qt::DirectConnection 来自不同于此对象线程的线程。不要在这种情景类型下使用此函数。
该函数在 Qt 4.8 引入。
另请参阅 sender (), QMetaObject::indexOfSignal ()，和 QMetaObject::method ().
使对象子级 parent .
设置值为对象的 name 特性到 value .
若有定义类特性使用 Q_PROPERTY 则成功返回 true，否则返回 false。若特性未定义使用 Q_PROPERTY ，因此未在元对象中列出，它被添加作为动态属性并返回 false。
所有可用特性的有关信息，提供透过 metaObject () 和 dynamicPropertyNames ().
动态特性可以被再次查询使用 property () 且可以被移除通过将特性值设为无效 QVariant 。更改动态特性值将导致 QDynamicPropertyChangeEvent 被发送给对象。
注意： 以 _q_ 开头的动态特性预留用于内部目的。
另请参阅 property (), metaObject (), dynamicPropertyNames ()，和 QMetaProperty::write ().
返回
true
若信号被阻塞；否则返回
false
.
信号不被阻塞，默认情况下。
另请参阅 blockSignals () 和 QSignalBlocker .
启动计时器并返回计时器标识符，或返回 0 若无法启动计时器。
计时器事件将出现每隔 interval 毫秒直到 killTimer () 被调用。若 interval 为 0，那么每当没有更多窗口系统事件要处理时，计时器事件就出现一次。
虚拟 timerEvent () 函数被调用采用 QTimerEvent 事件参数类当计时器事件出现时。重实现此函数能获取计时器事件。
若有多个计时器在运行， QTimerEvent::timerId () 可以用于找出激活了哪个计时器。
范例：
class MyObject : public QObject { Q_OBJECT public: MyObject(QObject *parent = 0); protected: void timerEvent(QTimerEvent *event); }; MyObject::MyObject(QObject *parent) : QObject(parent) { startTimer(50); // 50-millisecond timer startTimer(1000); // 1-second timer startTimer(60000); // 1-minute timer using namespace std::chrono; startTimer(milliseconds(50)); startTimer(seconds(1)); startTimer(minutes(1)); // since C++14 we can use std::chrono::duration literals, e.g.: startTimer(100ms); startTimer(5s); startTimer(2min); startTimer(1h); } void MyObject::timerEvent(QTimerEvent *event) { qDebug() << "Timer ID:" << event->timerId(); }
注意， QTimer 的精度从属底层操作系统和硬件。 timerType 自变量允许定制计时器的精度。见 Qt::TimerType 了解不同计时器类型的有关信息。大多数平台支持 20 毫秒的精度；某些提供更多。若 Qt 无法交付请求的计时器事件数，会默默地丢弃一些。
The QTimer 类提供高级编程接口，采用单发计时器和计时器信号而不是事件。还有 QBasicTimer 类更轻量相比 QTimer 且不像直接使用计时器 ID 那样笨重。
另请参阅 timerEvent (), killTimer ()，和 QTimer::singleShot ().
这是重载函数。
启动计时器并返回计时器标识符，或返回 0 若无法启动计时器。
计时器事件将出现每隔
time
间隔直到
killTimer
() 被调用。若
time
等于
std::chrono::duration::zero()
，那么每当没有更多窗口系统事件要处理时，计时器事件就出现一次。
虚拟 timerEvent () 函数被调用采用 QTimerEvent 事件参数类当计时器事件出现时。重实现此函数能获取计时器事件。
若有多个计时器在运行， QTimerEvent::timerId () 可以用于找出激活了哪个计时器。
范例：
class MyObject : public QObject { Q_OBJECT public: MyObject(QObject *parent = 0); protected: void timerEvent(QTimerEvent *event); }; MyObject::MyObject(QObject *parent) : QObject(parent) { startTimer(50); // 50-millisecond timer startTimer(1000); // 1-second timer startTimer(60000); // 1-minute timer using namespace std::chrono; startTimer(milliseconds(50)); startTimer(seconds(1)); startTimer(minutes(1)); // since C++14 we can use std::chrono::duration literals, e.g.: startTimer(100ms); startTimer(5s); startTimer(2min); startTimer(1h); } void MyObject::timerEvent(QTimerEvent *event) { qDebug() << "Timer ID:" << event->timerId(); }
注意， QTimer 的精度从属底层操作系统和硬件。 timerType 自变量允许定制计时器的精度。见 Qt::TimerType 了解不同计时器类型的有关信息。大多数平台支持 20 毫秒的精度；某些提供更多。若 Qt 无法交付请求的计时器事件数，会默默地丢弃一些。
The QTimer 类提供高级编程接口，采用单发计时器和计时器信号而不是事件。还有 QBasicTimer 类更轻量相比 QTimer 且不像直接使用计时器 ID 那样笨重。
该函数在 Qt 5.9 引入。
另请参阅 timerEvent (), killTimer ()，和 QTimer::singleShot ().
返回对象所在的线程。
另请参阅 moveToThread ().
[virtual protected]
void
QObject::
timerEvent
(
QTimerEvent
*
event
)
此事件处理程序可以在子类中重实现，以接收对象的计时器事件。
QTimer 为计时器功能提供更高级接口，及有关计时器的更一般信息。计时器事件被传入 event 参数。
另请参阅 startTimer (), killTimer ()，和 event ().
[static]
QString
QObject::
tr
(const
char
*
sourceText
, const
char
*
disambiguation
= Q_NULLPTR,
int
n
= -1)
返回翻译版本的 sourceText ，可选基于 disambiguation 字符串和值 n 对于包含多个的字符串；否则返回 QString::fromUtf8 ( sourceText ) 若没有合适的翻译字符串可用。
范例：
void MainWindow::createActions() { QMenu *fileMenu = menuBar()->addMenu(tr("&File")); ...
若相同 sourceText 用于同一上下文中的不同角色，可将额外标识字符串传入 disambiguation (0 默认情况下)。在 Qt 4.4 及更早版本，这是向翻译者传递注释的首选方式。
范例：
MyWindow::MyWindow() { QLabel *senderLabel = new QLabel(tr("Name:")); QLabel *recipientLabel = new QLabel(tr("Name:", "recipient")); ...
见 编写翻译源代码 了解 Qt 一般翻译机制的详细描述，和 消除歧义 章节了解消除歧义的有关信息。
警告： 此方法才可重入若有安装所有翻译器 before 调用此方法。不支持在履行翻译时，安装或移除翻译器。这样做可能会导致崩溃或其它不期望行为。
另请参阅 QCoreApplication::translate () 和 Qt 国际化 .
此变量存储类的元对象。
元对象包含的信息有关类继承 QObject ，如类名、超类名、特性、信号及槽。每个类包含 Q_OBJECT 宏也将拥有元对象。
元对象信息是信号/槽连接机制和特性系统要求的。 inherits () 函数还利用了元对象。
若拥有指向对象的指针，可以使用 metaObject () 以检索该对象关联的元对象。
范例：
QPushButton::staticMetaObject.className(); // returns "QPushButton" QObject *obj = new QPushButton; obj->metaObject()->className(); // returns "QPushButton"
另请参阅 metaObject ().
此函数重载 qFindChildren()。
此函数相当于 obj -> findChildren <T>( regExp ).
注意： 此函数是为不支持成员模板函数的 MSVC 6 提供的解决方案。建议在新代码中使用其它形式。
另请参阅 QObject::findChildren ().
返回给定 object 被铸造成 T 类型，若对象为 T 类型 (或子类)；否则返回 0。若 object 为 0 那么它也将返回 0。
类 T 必须继承 (直接或间接) QObject 并被声明采用 Q_OBJECT 宏。
类被认为继承本身。
范例：
QObject *obj = new QTimer; // QTimer inherits QObject QTimer *timer = qobject_cast<QTimer *>(obj); // timer == (QObject *)obj QAbstractButton *button = qobject_cast<QAbstractButton *>(obj); // button == 0
qobject_cast() 函数行为类似于标准 C++
dynamic_cast()
，它的优点是不要求 RTTI 支持，且跨动态库边界工作。
qobject_cast() 还可以与接口结合使用；见 插件和描绘 范例了解细节。
警告： 若 T 未被声明采用 Q_OBJECT 宏，此函数的返回值是不确定的。
另请参阅 QObject::inherits ().
定义此宏将禁用由信号携带的自变量与由槽接受的自变量之间的窄化和浮点到整型的转换，当使用基于 PMF 的句法连接信号和槽时。
该函数在 Qt 5.8 引入。
另请参阅 QObject::connect .
此宏将额外信息关联到类，是可用的使用 QObject::metaObject ()。Qt 仅有限使用此特征，在 Active Qt , Qt D-Bus and Qt QML .
额外信息接受形式化的 Name 字符串和 Value 文字字符串。
范例：
class MyClass : public QObject { Q_OBJECT Q_CLASSINFO("Author", "Pierre Gendron") Q_CLASSINFO("URL", "http://www.my-organization.qc.ca") public: ... };
另请参阅 QMetaObject::classInfo (), QAxFactory , 使用 Qt D-Bus 适配器 ，和 扩展 QML .
禁用拷贝构造函数和赋值运算符的使用为给定 Class .
实例化的子类 QObject 不应被认为是可以拷贝 (或赋值) 的值，而是作为唯一标识。这意味着当创建自己的子类化 QObject (直接或间接)，应 not 赋予它拷贝构造函数 (或赋值运算符)。不管怎样，从类中简单省略它们可能不够，因为，若过失编写了一些要求拷贝构造函数 (或赋值运算符) 的代码 (这很容易做到)，编译器会体贴地为您创建它。您必须做更多。
好奇用户将看到 Qt 类派生自 QObject 通常包括此宏在私有区间：
class MyClass : public QObject { private: Q_DISABLE_COPY(MyClass) };
在私有区间声明拷贝构造函数和赋值运算符，所以，若过失使用了它们，编译器会报错。
class MyClass : public QObject { private: MyClass(const MyClass &); MyClass &operator=(const MyClass &); };
即使这样，也绝对不可能捕获每种情况。可能被诱惑做像这样的一些事：
QWidget w = QWidget();
首先，不要这样做。大多数编译器将生成使用拷贝构造函数的代码，所以会报告违反隐私错误，但不要求 C++ 编译器以特定方式为该语句生成代码。可以生成代码使用
neither
拷贝构造函数
nor
私有赋值运算符。这种情况不会报错，但应用程序可能崩溃当调用成员函数从
w
.
使用此宏替换
emit
关键词对于发射信号，当想要使用 Qt 信号和槽采用
第 3 方信号/槽机制
.
通常使用宏当
no_keywords
的指定是采用
CONFIG
变量在
.pro
文件，但可以使用它甚至在
no_keywords
is
not
指定。
此宏采用元对象系统注册枚举类型。它必须放在类枚举声明之后，类有 Q_OBJECT 或 Q_GADGET 宏。对于名称空间使用 Q_ENUM_NS () 代替。
例如：
class MyClass : public QObject { Q_OBJECT public: MyClass(QObject *parent = 0); ~MyClass(); enum Priority { High, Low, VeryHigh, VeryLow }; Q_ENUM(Priority) void setPriority(Priority priority); Priority priority() const; };
采用 Q_ENUM 声明的枚举有自已的 QMetaEnum 注册在封闭 QMetaObject 。还可以使用 QMetaEnum::fromType () 以获取 QMetaEnum .
已注册枚举也会自动注册到 Qt 元类型系统，以使它们知道 QMetaType 无需使用 Q_DECLARE_METATYPE ()。这将启用有用特征；例如，若用于 QVariant ，可以将它们转换成字符串。同样，将它们传递给 QDebug 将打印出它们的名称。
该函数在 Qt 5.5 引入。
另请参阅 Qt 的特性系统 .
此宏向元对象系统注册枚举类型。必须将它放在枚举声明后若命名空间中有 Q_namespace 宏。如同 Q_ENUM 但在名称空间中。
采用 Q_ENUM_NS 声明的枚举有自已的 QMetaEnum 注册在封闭 QMetaObject 。还可以使用 QMetaEnum::fromType () 以获取 QMetaEnum .
已注册枚举也会自动注册到 Qt 元类型系统，以使它们知道 QMetaType 无需使用 Q_DECLARE_METATYPE ()。这将启用有用特征；例如，若用于 QVariant ，可以将它们转换成字符串。同样，将它们传递给 QDebug 将打印出它们的名称。
该函数在 Qt 5.8 引入。
另请参阅 Qt 的特性系统 .
此宏注册单 标志类型 采用元对象系统。通常用于类定义，以声明可以用作标志的给定枚举值，并使用按位 OR 运算符进行组合。对于名称空间，使用 Q_FLAG_NS () 代替。
宏必须放在枚举声明后。
例如，在 QLibrary ， LoadHints 标志的声明方式如下：
class QLibrary : public QObject { Q_OBJECT public: ... enum LoadHint { ResolveAllSymbolsHint = 0x01, ExportExternalSymbolsHint = 0x02, LoadArchiveMemberHint = 0x04 }; Q_DECLARE_FLAGS(LoadHints, LoadHint) Q_FLAG(LoadHints) ... }
标志自身声明的履行是在公共部分 QLibrary 类本身，使用 Q_DECLARE_FLAGS () 宏。
注意： Q_FLAG 宏负责采用元对象系统注册各个标志值，所以不必使用 Q_ENUM () 除此宏外。
该函数在 Qt 5.5 引入。
另请参阅 Qt 的特性系统 .
此宏注册单 标志类型 with the meta-object system. It is used in a namespace that has the Q_NAMESPACE macro, to declare that values of a given enum can be used as flags and combined using the bitwise OR operator. It is the same as Q_FLAG 但在名称空间中。
宏必须放在枚举声明后。
注意： Q_FLAG_NS 宏负责采用元对象系统注册单个标志值，因此不必使用 Q_ENUM_NS () 除此宏外。
该函数在 Qt 5.8 引入。
另请参阅 Qt 的特性系统 .
Q_GADGET 宏是更轻版本的 Q_OBJECT 宏，对于类不继承 QObject 但仍想使用某些反射能力提供通过 QMetaObject 。就像 Q_OBJECT 宏，它必须出现在类定义私有区间。
Q_GADGET 可以拥有 Q_ENUM , Q_PROPERTY and Q_INVOKABLE ，但它们无法拥有信号或槽
Q_GADGET 使类成员，
staticMetaObject
，可用。
staticMetaObject
是类型
QMetaObject
并提供对采用 Q_ENUMS 声明枚举的访问。
此宏告诉 Qt 类实现哪些接口。使用这当实现插件时。
范例：
class BasicToolsPlugin : public QObject, public BrushInterface, public ShapeInterface, public FilterInterface { Q_OBJECT Q_PLUGIN_METADATA(IID "org.qt-project.Qt.Examples.PlugAndPaint.BrushInterface" FILE "basictools.json") Q_INTERFACES(BrushInterface ShapeInterface FilterInterface) public: ... };
见 插件和描绘基本工具 范例了解细节。
另请参阅 Q_DECLARE_INTERFACE (), Q_PLUGIN_METADATA ()，和 如何创建 Qt 插件 .
将此宏应用于成员函数声明，以允许凭借元对象系统援引它们。宏写在返回类型之前，如以下范例所示：
class Window : public QWidget { Q_OBJECT public: Window(); void normalMethod(); Q_INVOKABLE void invokableMethod(); };
The
invokableMethod()
函数使用 Q_INVOKABLE 进行标记，导致它向元对象系统注册并使其能够被援引使用
QMetaObject::invokeMethod
()。由于
normalMethod()
函数未按此方式注册，不可以援引它使用
QMetaObject::invokeMethod
().
Q_OBJECT 宏必须出现在类定义的私有区间，声明自身的信号和槽，或使用由 Qt 元对象系统提供的其它服务。
例如：
#include <QObject> class Counter : public QObject { Q_OBJECT public: Counter() { m_value = 0; } int value() const { return m_value; } public slots: void setValue(int value); signals: void valueChanged(int newValue); private: int m_value; };
注意： 此宏要求类是子类化的 QObject 。使用 Q_GADGET 而不是 Q_OBJECT 来启用元对象系统类枚举支持，不要求是 QObject 子类。
另请参阅 元对象系统 , 信号和槽 ，和 Qt 的特性系统 .
此宏用于声明类特性，当继承 QObject 。特性的行为像类数据成员，但它们拥有的额外特征可访问透过 元对象系统 .
Q_PROPERTY(type name
(READ getFunction [WRITE setFunction] |
MEMBER memberName [(READ getFunction | WRITE setFunction)])
[RESET resetFunction]
[NOTIFY notifySignal]
[REVISION int]
[DESIGNABLE bool]
[SCRIPTABLE bool]
[STORED bool]
[USER bool]
[CONSTANT]
[FINAL])
特性名称和类型及
READ
函数是要求的。可以是任何类型的类型支持通过
QVariant
，或它可以是用户定义类型。其它项可选，但
WRITE
函数是公共的。属性默认为 true 除了
USER
，其默认为 false。
例如：
Q_PROPERTY(QString title READ title WRITE setTitle USER true)
有关如何使用此宏的更多细节，和其用法的更详细范例，见讨论在 Qt 的特性系统 .
另请参阅 Qt 的特性系统 .
将此宏应用到成员函数声明，以在元对象系统中采用修订号标记它们。宏写在返回类型之前，如以下范例所示：
class Window : public QWidget { Q_OBJECT Q_PROPERTY(int normalProperty READ normalProperty) Q_PROPERTY(int newProperty READ newProperty REVISION 1) public: Window(); int normalProperty(); int newProperty(); public slots: void normalMethod(); Q_REVISION(1) void newMethod(); };
这很有用当使用元对象系统将对象动态暴露给另一 API 时，因为可以匹配由其它 API 的多个版本所期望的版本。考虑以下简化范例：
Window window;
int expectedRevision = 0;
const QMetaObject *windowMetaObject = window.metaObject();
for (int i=0; i < windowMetaObject->methodCount(); i++)
if (windowMetaObject->method(i).revision() <= expectedRevision)
exposeMethod(windowMetaObject->method(i));
for (int i=0; i < windowMetaObject->propertyCount(); i++)
if (windowMetaObject->property(i).revision() <= expectedRevision)
exposeProperty(windowMetaObject->property(i));
使用如先前范例的相同 Window 类，才会在此代码中暴露 newProperty 和 newMethod 当期望版本为 1 或更大时
由于认为所有方法在修订 0 中 (若未标记)，所以标记 Q_REVISION(0) 无效且会被忽略。
元对象系统本身不使用此标记。目前这只用于 QtQml 模块。
对于更一般字符串标签，见 QMetaMethod::tag ()
另请参阅 QMetaMethod::revision ().
此宏赋值 Object 对象名 Object。
它不管是否 Object 是指针或不是指针，宏自己会弄清楚。
该函数在 Qt 5.0 引入。
另请参阅 QObject::objectName ().
这是允许将单个函数，标记为信号的额外宏。它可能非常有用，尤其是当使用第 3 方源代码剖析器不理解
signals
or
Q_SIGNALS
组。
使用此宏替换
signals
关键词在类声明中，当想要使用 Qt 信号和槽采用
第 3 方信号/槽机制
.
通常使用宏当
no_keywords
的指定是采用
CONFIG
变量在
.pro
文件，但可以使用它甚至在
no_keywords
is
not
指定。
使用此宏替换
signals
关键词在类声明中，当想要使用 Qt 信号和槽采用
第 3 方信号/槽机制
.
通常使用宏当
no_keywords
的指定是采用
CONFIG
变量在
.pro
文件，但可以使用它甚至在
no_keywords
is
not
指定。
这是允许将单个函数，标记为槽的额外宏。它可能非常有用，尤其是当使用第 3 方源代码剖析器不理解
slots
or
Q_SLOTS
组。
使用此宏替换
slots
关键词在类声明中，当想要使用 Qt 信号和槽采用
第 3 方信号/槽机制
.
通常使用宏当
no_keywords
的指定是采用
CONFIG
变量在
.pro
文件，但可以使用它甚至在
no_keywords
is
not
指定。
使用此宏替换
slots
关键词在类声明中，当想要使用 Qt 信号和槽采用
第 3 方信号/槽机制
.
通常使用宏当
no_keywords
的指定是采用
CONFIG
变量在
.pro
文件，但可以使用它甚至在
no_keywords
is
not
指定。