内容

特性
公共函数
公共槽
信号
静态公共成员
保护函数
相关非成员
宏
详细描述
线程亲缘关系
No copy constructor or assignment operator
自动连接
动态特性
国际化 (i18n)

QObject 类

The QObject 类是所有 Qt 对象的基类。更多...

头：	#include <QObject>
实例化：	QtObject
继承者：	Maemo::DBusDispatcher , Phonon::AudioDataOutput , Phonon::AudioOutput , Phonon::BackendCapabilities::Notifier , Phonon::Effect , Phonon::MediaController , Phonon::MediaObject , Q3Accel , Q3Action , Q3Canvas , Q3Dns , Q3DragObject , Q3EditorFactory , Q3FileIconProvider , Q3NetworkOperation , Q3NetworkProtocol , Q3Process , Q3ServerSocket , Q3Signal , Q3SqlForm , Q3StyleSheet , Q3WhatsThis , QAbstractAnimation , QAbstractEventDispatcher , QAbstractFontEngine , QAbstractItemDelegate , QAbstractItemModel , QAbstractMessageHandler , QAbstractNetworkCache , QAbstractState , QAbstractTextDocumentLayout , QAbstractTransition , QAbstractUriResolver , QAbstractVideoSurface , QAccessibleBridgePlugin , QAccessiblePlugin , QAction , QActionGroup , QAudioInput , QAudioOutput , QAxFactory , QAxObject , QAxScript , QAxScriptManager , QButtonGroup , QClipboard , QCompleter , QCopChannel , QCoreApplication , QDataWidgetMapper , QDBusAbstractAdaptor , QDBusAbstractInterface , QDBusPendingCallWatcher , QDBusServiceWatcher , QDeclarativeComponent , QDeclarativeContext , QDeclarativeEngine , QDeclarativeExpression , QDeclarativeExtensionPlugin , QDeclarativePropertyMap , QDecorationPlugin , QDesignerFormEditorInterface , QDesignerFormWindowManagerInterface , QDirectPainter , QDrag , QEventLoop , QExtensionFactory , QExtensionManager , QFileSystemWatcher , QFontEnginePlugin , QFtp , QFutureWatcher , QGenericPlugin , QGesture , QGLShader , QGLShaderProgram , QGraphicsAnchor , QGraphicsEffect , QGraphicsItemAnimation , QGraphicsObject , QGraphicsScene , QGraphicsTransform , QHelpEngineCore , QHelpSearchEngine , QHttp , QHttpMultiPart , QIconEnginePlugin , QIconEnginePluginV2 , QImageIOPlugin , QInputContext , QInputContextPlugin , QIODevice , QItemSelectionModel , QKbdDriverPlugin , QLayout , QLibrary , QLocalServer , QMimeData , QMouseDriverPlugin , QMovie , QNetworkAccessManager , QNetworkConfigurationManager , QNetworkCookieJar , QNetworkSession , QObjectCleanupHandler , QPictureFormatPlugin , QPlatformCursor , QPluginLoader , QScreenDriverPlugin , QScriptEngine , QScriptEngineDebugger , QScriptExtensionPlugin , QSessionManager , QSettings , QSharedMemory , QShortcut , QSignalMapper , QSignalSpy , QSocketNotifier , QSound , QSqlDriver , QSqlDriverPlugin , QStyle , QStylePlugin , QSvgRenderer , QSyntaxHighlighter , QSystemTrayIcon , QTcpServer , QTextCodecPlugin , QTextDocument , QTextObject , QThread , QThreadPool , QTimeLine , QTimer , QTranslator , QUiLoader , QUndoGroup , QUndoStack , QValidator , QWebFrame , QWebHistoryInterface , QWebPage , QWebPluginFactory , QWidget , QWSClient , QWSInputMethod ，和 QWSServer

注意： 此类的所有函数可重入，但 connect (), connect (), disconnect ()，和 disconnect () are also thread-safe .

特性

objectName : QString

公共函数

	QObject (QObject * parent = 0)
virtual	~QObject ()
bool	blockSignals (bool block )
const QObjectList &	children () const
bool	connect (const QObject * sender , const char * signal , const char * method , Qt::ConnectionType type = Qt::AutoConnection) const
bool	disconnect (const char * signal = 0, const QObject * receiver = 0, const char * method = 0)
bool	disconnect (const QObject * receiver , const char * method = 0)
void	dumpObjectInfo ()
void	dumpObjectTree ()
QList<QByteArray>	dynamicPropertyNames () const
virtual bool	event (QEvent * e )
virtual bool	eventFilter (QObject * watched , QEvent * event )
T	findChild (const QString & name = QString()) const
QList<T>	findChildren (const QString & name = QString()) const
QList<T>	findChildren (const QRegExp & regExp ) const
bool	inherits (const char * className ) const
void	installEventFilter (QObject * filterObj )
bool	isWidgetType () 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 )
QThread *	thread () const

公共槽

void	deleteLater ()

信号

void	destroyed (QObject * obj = 0)

静态公共成员

bool	connect (const QObject * sender , const char * signal , const QObject * receiver , const char * method , Qt::ConnectionType type = Qt::AutoConnection)
bool	connect (const QObject * sender , const QMetaMethod & signal , const QObject * receiver , const QMetaMethod & method , 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 )
const QMetaObject	staticMetaObject
QString	tr (const char * sourceText , const char * disambiguation = 0, int n = -1)
QString	trUtf8 (const char * sourceText , const char * disambiguation = 0, int n = -1)

保护函数

virtual void	childEvent (QChildEvent * event )
virtual void	connectNotify (const char * signal )
virtual void	customEvent (QEvent * event )
virtual void	disconnectNotify (const char * signal )
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 )

宏

	Q_CLASSINFO ( Name , Value )
	Q_DISABLE_COPY ( Class )
	Q_EMIT
	Q_ENUMS (...)
	Q_FLAGS (...)
	Q_INTERFACES (...)
	Q_INVOKABLE
	Q_OBJECT
	Q_PROPERTY (...)
	Q_SIGNAL
	Q_SIGNALS
	Q_SLOT
	Q_SLOTS

详细描述

The QObject 类是所有 Qt 对象的基类。

QObject 是心脏在 Qt 对象模型。该模型的中心特征是非常强大的无缝对象通信机制，称为信号和槽。可以连接信号到槽采用 connect () 和销毁连接采用 disconnect ()。为避免从不结束通知循环，可以临时阻塞信号采用 blockSignals ()。保护函数 connectNotify () 和 disconnectNotify () 使之可能跟踪连接。

QObjects organize themselves in 对象树。当创建 QObject 采用另一对象作为父级，对象将自动把自身添加到父级的 children () 列表。父级拥有对象的所有权；即：它将在其析构函数中自动删除其子级。可以查找对象通过名称和可选类型，使用 findChild () 或 findChildren ().

每个对象都有 objectName () 且可以找到其类名凭借相应 metaObject () (见 QMetaObject::className ())。可以确定对象的类是否继承另一个类在 QObject 继承层次结构通过使用 inherits () 函数。

当对象被删除时，它发射 destroyed () signal. You can catch this signal to avoid dangling references to QObjects .

QObjects can receive events through 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 ().

所有 QObjects must live in the same thread as their parent. Consequently:

setParent () will fail if the two QObjects involved live in different threads.
当 QObject 被移到另一线程，它的所有子级也会自动被移动。
moveToThread () 将失败，若 QObject 有父级。
若 QObject s are created within QThread::run ()，它们无法变为子级化 QThread 对象因为 QThread 未存活于线程，当调用 QThread::run ().

注意： A QObject 的成员变量 do not 自动变为其子级。父/子关系的设置必须通过将指针传递给子级的 constructor ，或者通过调用 setParent ()。没有这一步，对象的成员变量会留在旧线程中当 moveToThread () 被调用。

No copy constructor or assignment operator

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 和用户创建的表单两者都可以赋予动态特性。

国际化 (i18n)

所有 QObject 子类都支持 Qt 翻译特征，使之可能将应用程序用户界面翻译成不同语言。

为使对用户可见的文本可翻译，必须将它包裹在调用 tr () 函数。这的详细解释在编写翻译源代码文档。

另请参阅 QMetaObject , QPointer , QObjectCleanupHandler , Q_DISABLE_COPY ()，和对象树 & 所有权 .

特性文档编制

objectName : QString

This property holds the name of this object.

可按名称 (和类型) 查找对象，使用 findChild ()。可找到一组对象采用 findChildren ().

qDebug("MyClass::setPrecision(): (%s) invalid precision %f",
       qPrintable(objectName()), newPrecision);

默认情况下，此特性包含空字符串。

访问函数：

QString	objectName () const
void	setObjectName (const QString & name )

另请参阅 metaObject () 和 QMetaObject::className ().

成员函数文档编制

QObject:: QObject ( QObject * parent = 0)

构造对象采用父级对象 parent .

对象的父级可以被视为对象的所有者。例如，对话框是父级对于 OK and Cancel 按钮 (它包含的)。

父级对象的析构函数会销毁所有子级对象。

设置 parent 为 0 构造没有父级的对象。若对象是 Widget，它将变为顶层窗口。

另请参阅 parent (), findChild ()，和 findChildren ().

`[虚拟]` QObject:: ~QObject ()

销毁对象，删除其所有子级对象。

自动断开到/自对象的所有信号连接，并从事件队列移除对象的任何待决张贴事件。不管怎样，经常更安全使用 deleteLater () 而不是删除 QObject 子类直接。

警告： 删除所有子级对象。若这些对象中的任一在堆栈 (或全局) 中，程序迟早会崩溃。不推荐从父级外部保持子级对象的指针。若仍然这样做， destroyed () 信号给予机会以检测对象何时被销毁。

警告： 删除 QObject 当等待交付的待决事件会导致崩溃时。不得删除 QObject 直接，若它存在于目前执行线程的不同线程中。使用 deleteLater () 代替，将导致事件循环删除对象在所有待决事件被交付给对象之后。

另请参阅 deleteLater ().

bool QObject:: blockSignals ( bool block )

若 block 为 true，阻塞由此对象发射的信号 (即：发射信号不会援引与其连接的任何东西)。若 block 为 false，不会发生这种阻塞。

返回值是先前值的 signalsBlocked ().

注意， destroyed () 信号会被发射，即使此对象的信号已被阻塞。

另请参阅 signalsBlocked ().

`[virtual protected]` void QObject:: childEvent ( QChildEvent * event )

可以在子类中重实现此事件处理程序以接收子级事件。事件被传入 event 参数。

QEvent::ChildAdded and QEvent::ChildRemoved 事件被发送给对象，当添加或移除子级时。在这 2 种情况下，只能依赖的子级是 QObject ，或者若 isWidgetType () returns true, a QWidget 。(这是因为，在 ChildAdded 情况下，子级尚未被完全构造，而在 ChildRemoved 情况下，它可能已经被销毁)。

QEvent::ChildPolished 事件被发送给 Widget 当子级被抛光时，或者当添加抛光子级时。若收到子级抛光事件，子级的构造通常已完成。不管怎样，这不保证，且在 Widget 构造函数执行期间可能交付多个抛光事件。

对于每个子级 Widget，接收一个 ChildAdded 事件，零个或多个 ChildPolished 事件，和一个 ChildRemoved 事件。

The ChildPolished 事件被省略若子级立即被移除在被添加之后。若子级在构建和销毁期间中被多次抛光，则可能收到同一子级的几个子级抛光事件，每次采用不同虚拟表格。

另请参阅 event ().

const QObjectList & QObject:: children () const

返回子级对象的列表。 QObjectList 类的定义在 <QObject> 头文件，如下所示：

typedef QList<QObject*> QObjectList;

第一添加子级是 first 对象在列表中，且最后添加子级是 last 对象在列表中，即：新子级被追加在末尾。

注意：列表次序改变，当 QWidget 子级 raised or lowered 。被提升 Widget 变为最后列表对象，被降低 Widget 变为第一列表对象。

另请参阅 findChild (), findChildren (), parent ()，和 setParent ().

`[static]` bool QObject:: connect (const QObject * sender , const char * signal , const QObject * receiver , const char * method , Qt::ConnectionType type = Qt::AutoConnection)

创建连接为给定 type 从 signal 在 sender 对象到 method 在 receiver object. Returns true if the connection succeeds; otherwise returns false.

必须使用 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 .

信号可以连接到多个槽和信号。多个信号可以连接到一个槽。

If a signal is connected to several slots, the slots are activated in the same order as the order the connection was made, when the signal is emitted.

The function returns true if it successfully connects the signal to the slot. It will return false if it cannot create the connection, for example, if QObject 无法验证存在 signal or method , or if their signatures aren't compatible.

默认情况下，制作的每个连接都会发出信号；重复连接发射 2 个信号。可以断开所有这些连接采用一个 disconnect () 调用。若传递 Qt::UniqueConnection type , the connection will only be made if it is not a duplicate. If there is already a duplicate (exact same signal to the exact same slot on the same objects), the connection will fail and connect will return false.

可选 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]` bool QObject:: connect (const QObject * sender , const QMetaMethod & signal , const QObject * receiver , const QMetaMethod & method , Qt::ConnectionType type = Qt::AutoConnection)

创建连接为给定 type 从 signal 在 sender 对象到 method 在 receiver object. Returns true if the connection succeeds; otherwise returns false.

This function works in the same way as connect(const QObject *sender, const char *signal, const QObject *receiver, const char *method, Qt::ConnectionType type) but it uses QMetaMethod 来指定信号和方法。

该函数在 Qt 4.8 引入。

另请参阅 connect(const QObject *sender, const char *signal, const QObject *receiver, const char *method, Qt::ConnectionType type).

bool QObject:: connect (const QObject * sender , const char * signal , const char * method , Qt::ConnectionType type = Qt::AutoConnection) const

此函数重载 connect ().

连接 signal 从 sender 对象到此对象的 method .

相当于 connect( sender , signal , this , method , type ).

每个建立连接都会发射信号，因此重复连接会发射 2 个信号。可以断开连接使用 disconnect ().

注意： 此函数是 thread-safe .

另请参阅 disconnect ().

`[virtual protected]` void QObject:: connectNotify (const char * signal )

此虚函数被调用当某些东西已连接到 signal 在此对象。

若想要比较 signal with a specific signal, use QLatin1String 和 SIGNAL() macro as follows:

if (QLatin1String(signal) == SIGNAL(valueChanged(int))) {
    // signal is valueChanged(int)
}

If the signal contains multiple parameters or parameters that contain spaces, call QMetaObject::normalizedSignature () on the result of the SIGNAL() 宏。

警告： 此函数违反了面向对象的模块化原则。不管怎样，它可能很有用仅当某些东西连接到信号时，才需要履行昂贵的初始化。

另请参阅 connect () 和 disconnectNotify ().

`[virtual protected]` void QObject:: customEvent ( QEvent * event )

可以在子类中重实现此事件处理程序，以接收自定义事件。自定义事件是用户定义事件，具有类型值至少一样大如 QEvent::User 项的 QEvent::Type 枚举, 且通常是 QEvent 子类。事件被传入 event 参数。

另请参阅 event () 和 QEvent .

`[slot]` void QObject:: deleteLater ()

调度删除此对象。

将删除对象，当控制返回给事件循环时。若事件循环未运行，当调用此函数时 (如，对象调用 deleteLater() 先于 QCoreApplication::exec ())，会删除对象，一旦启动事件循环。若在 main 事件循环已停止后调用 deleteLater()，就不会删除对象。从 Qt 4.8 起，若活在未运行事件循环线程中的对象调用 deleteLater()，就不会销毁对象当线程完成时。

注意：进入和离开新事件循环 (如，通过打开模态对话框) 会 not 履行延迟删除；对于要删除对象，控制必须返回给调用 deleteLater() 的事件循环。

注意： 多次调用此函数是安全的；当交付首个延迟删除事件时，会从事件队列移除对象的任何待决事件。

另请参阅 destroyed () 和 QPointer .

`[signal]` void QObject:: destroyed ( QObject * obj = 0)

此信号立即发射先于对象 obj 被销毁，且不阻塞。

立即销毁对象的所有子级，在此信号发射后。

另请参阅 deleteLater () 和 QPointer .

`[static]` bool QObject:: disconnect (const QObject * sender , const char * signal , const QObject * receiver , const char * method )

断开连接 signal 在对象 sender from method 在对象 receiver . Returns true if the connection is successfully broken; otherwise returns 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 . Returns true if the connection is successfully broken; otherwise returns false.

This function provides the same possibilities like disconnect(const QObject *sender, const char *signal, const QObject *receiver, const char *method) but uses QMetaMethod 来表示要断开的信号和方法。

Additionally this function returnsfalse and no signals and slots disconnected if:

signal 不是发送者类成员 (或其父级类成员)。
method 不是接收者类成员 (或其父级类成员)。
signal 实例表示不是信号。

QMetaMethod() 可以用作通配符，意味着任何信号、或在接收对象中的任何槽。以相同方式，0 可以用于 receiver 意味着任何接收对象。在此情况下，方法也应该是 QMetaMethod()。 sender 参数从不应该为 0。

该函数在 Qt 4.8 引入。

另请参阅 disconnect(const QObject *sender, const char *signal, const QObject *receiver, const char *method).

bool QObject:: disconnect (const char * signal = 0, const QObject * receiver = 0, const char * method = 0)

此函数重载 disconnect ().

断开连接 signal from method of receiver .

信号/槽连接被移除，当涉及的对象被销毁时。

注意： 此函数是 thread-safe .

bool QObject:: disconnect (const QObject * receiver , const char * method = 0)

此函数重载 disconnect ().

断开连接此对象的所有信号从 receiver 's method .

信号/槽连接被移除，当涉及的对象被销毁时。

`[virtual protected]` void QObject:: disconnectNotify (const char * signal )

此虚函数被调用当某些东西已断开连接从 signal 在此对象。

见 connectNotify () 例如如何比较 signal 采用特定信号。

警告： 此函数违反了面向对象的模块化原则。不管怎样，它可能很有用为优化昂贵资源的访问。

另请参阅 disconnect () 和 connectNotify ().

void QObject:: dumpObjectInfo ()

将有关此对象的信号连接等信息转储到调试输出。

This function is useful for debugging, but does nothing if the library has been compiled in release mode (i.e. without debugging information).

另请参阅 dumpObjectTree ().

void QObject:: dumpObjectTree ()

将子级树转储到调试输出。

This function is useful for debugging, but does nothing if the library has been compiled in release mode (i.e. without debugging information).

另请参阅 dumpObjectInfo ().

QList < QByteArray > QObject:: dynamicPropertyNames () const

返回被动态添加到对象的所有特性的名称，使用 setProperty ().

该函数在 Qt 4.2 引入。

`[虚拟]` bool QObject:: event ( QEvent * e )

此虚函数接收对象事件并返回 true，若事件 e 被识别并处理。

event() 函数可以被重实现，以定制对象行为。

另请参阅 installEventFilter (), timerEvent (), QApplication::sendEvent (), QApplication::postEvent ()，和 QWidget::event ().

`[虚拟]` 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 QObject:: findChild (const QString & name = QString()) const

返回此对象的子级可以被铸造成 T 类型且被称为 name ，或 0 若没有这种对象。省略 name argument causes all object names to be matched. The search is performed recursively.

若有多个子级匹配搜索，返回最直接祖先。若有多个直接祖先，返回哪个未定义。在此情况下， findChildren () 应该被使用。

此范例返回子级 QPushButton of parentWidget 命名 "button1" :

QPushButton *button = parentWidget->findChild<QPushButton *>("button1");

此范例返回 QListWidget 子级对于 parentWidget :

QListWidget *list = parentWidget->findChild<QListWidget *>();

另请参阅 findChildren ().

QList < T > QObject:: findChildren (const QString & name = QString()) const

返回此对象的所有子级具有给定 name 可以被铸造成 T 类型，或空列表若没有这种对象。省略 name argument causes all object names to be matched. The search is performed recursively.

以下范例展示如何查找列表化的子级 QWidget 为指定 parentWidget 命名 widgetname :

QList<QWidget *> widgets = parentWidget.findChildren<QWidget *>("widgetname");

此范例返回所有 QPushButton 其是子级对于 parentWidget :

QList<QPushButton *> allPButtons = parentWidget.findChildren<QPushButton *>();

另请参阅 findChild ().

QList < T > QObject:: findChildren (const QRegExp & regExp ) const

此函数重载 findChildren ().

返回此对象的子级，可以被铸造成 T 类型且拥有的名称匹配正则表达式 regExp , or an empty list if there are no such objects. The search is performed recursively.

bool QObject:: inherits (const char * className ) const

Returns true if this object is an instance of a class that inherits 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 ().

void QObject:: installEventFilter ( QObject * filterObj )

安装事件过滤器 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 ().

bool QObject:: isWidgetType () const

Returns true if the object is a widget; otherwise returns false.

Calling this function is equivalent to calling inherits(" QWidget "), except that it is much faster.

void QObject:: killTimer ( int id )

杀除计时器采用计时器标识符， 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 .

void QObject:: moveToThread ( QThread * targetThread )

更改此对象及其子级的线程亲缘关系。对象无法被移动，若它有父级。事件处理将继续在 targetThread .

要将对象移至主线程，使用 QApplication::instance () 检索指向当前应用程序的指针，然后使用 QApplication::thread () 来检索应用程序在其中存活的线程。例如：

myObject->moveToThread(QApplication::instance()->thread());

若 targetThread 为 0，停止此对象及其子级的所有事件处理。

注意，对象的所有活动计时器都将被重置。计时器先在当前线程中停止并重启 (采用相同间隔) 在 targetThread 。因此，在线程之间不断移动对象可以无限期推迟计时器事件。

A QEvent::ThreadChange 事件被发送给此对象，恰好在改变线程亲缘关系之前。可以处理此事件以履行任何特殊处理。注意，张贴给此对象的任何新事件都将被处理在 targetThread .

警告： 此函数是 not 线程安全的；当前线程必须与当前线程亲缘关系相同。换句话说，此函数只可以把对象从当前线程 "压入" 到另一线程，它不可以从任意线程 "拉出" 对象到当前线程。

另请参阅 thread ().

QObject * QObject:: parent () const

返回指向父级对象的指针。

另请参阅 setParent () 和 children ().

QVariant QObject:: property (const char * name ) const

返回值为对象的 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);
}

如以上代码片段阐明，可以使用此函数以避免发射无人监听的信号。

警告： 此函数违反了面向对象的模块化原则。不管怎样，它可能很有用仅当某些东西连接到信号时，才需要履行昂贵的初始化。

void QObject:: removeEventFilter ( QObject * obj )

移除事件过滤器对象 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 ().

void QObject:: setParent ( QObject * parent )

使对象子级 parent .

另请参阅 parent () 和 QWidget::setParent ().

bool QObject:: setProperty (const char * name , const QVariant & value )

设置值为对象的 name 特性到 value .

若有定义类特性使用 Q_PROPERTY 则成功返回 true，否则返回 false。若特性未定义使用 Q_PROPERTY ，因此未在元对象中列出，它被添加作为动态属性并返回 false。

所有可用特性的有关信息，提供透过 metaObject () 和 dynamicPropertyNames ().

动态特性可以被再次查询使用 property () 且可以被移除通过将特性值设为无效 QVariant 。更改动态特性值将导致 QDynamicPropertyChangeEvent 被发送给对象。

注意： 以 _q_ 开头的动态特性预留用于内部目的。

另请参阅 property (), metaObject ()，和 dynamicPropertyNames ().

bool QObject:: signalsBlocked () const

Returns true if signals are blocked; otherwise returns false.

信号不被阻塞，默认情况下。

另请参阅 blockSignals ().

int QObject:: startTimer ( int interval )

启动计时器并返回计时器标识符，或返回 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
}
void MyObject::timerEvent(QTimerEvent *event)
{
    qDebug() << "Timer ID:" << event->timerId();
}

注意， QTimer 's accuracy depends on the underlying operating system and hardware. Most platforms support an accuracy of 20 milliseconds; some provide more. If Qt is unable to deliver the requested number of timer events, it will silently discard some.

The QTimer 类提供高级编程接口，采用单发计时器和计时器信号而不是事件。还有 QBasicTimer 类更轻量相比 QTimer 且不像直接使用计时器 ID 那样笨重。

另请参阅 timerEvent (), killTimer ()，和 QTimer::singleShot ().

QThread * QObject:: thread () const

返回对象所在的线程。

另请参阅 moveToThread ().

`[virtual protected]` void QObject:: timerEvent ( QTimerEvent * event )

此事件处理程序可以在子类中重实现，以接收对象的计时器事件。

QTimer 为计时器功能提供更高级接口，及有关计时器的更一般信息。计时器事件被传入 event 参数。

另请参阅 startTimer (), killTimer ()，和 event ().

`[static]` QString QObject:: tr (const char * sourceText , const char * disambiguation = 0, int n = -1)

返回翻译版本的 sourceText ，可选基于 disambiguation 字符串和值 n 对于包含多个的字符串；否则返回 sourceText itself if no appropriate translated string is available.

范例：

void MainWindow::createMenus()
{
    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 调用此方法。不支持在履行翻译时，安装或移除翻译器。这样做可能会导致崩溃或其它不期望行为。

另请参阅 trUtf8 (), QApplication::translate (), QTextCodec::setCodecForTr ()，和 Qt 国际化 .

`[static]` QString QObject:: trUtf8 (const char * sourceText , const char * disambiguation = 0, int n = -1)

返回翻译版本的 sourceText ，或 QString::fromUtf8 ( sourceText ) if there is no appropriate version. It is otherwise identical to tr( sourceText , disambiguation , n ).

Note that using the Utf8 variants of the translation functions is not required if CODECFORTR is already set to UTF-8 in the qmake project file and QTextCodec::setCodecForTr ("UTF-8") is used.

警告： For portability reasons, we recommend that you use escape sequences for specifying non-ASCII characters in string literals to trUtf8(). For example:

label->setText(tr("F\374r \310lise"));

另请参阅 tr (), QApplication::translate ()，和 Qt 国际化 .

成员变量文档编制

const QMetaObject QObject:: staticMetaObject

此变量存储类的元对象。

元对象包含的信息有关类继承 QObject ，如类名、超类名、特性、信号及槽。每个类包含 Q_OBJECT 宏也将拥有元对象。

元对象信息是信号/槽连接机制和特性系统要求的。 inherits () 函数还利用了元对象。

若拥有指向对象的指针，可以使用 metaObject () 以检索该对象关联的元对象。

范例：

QPushButton::staticMetaObject.className();  // returns "QPushButton"
QObject *obj = new QPushButton;
obj->metaObject()->className();             // returns "QPushButton"

另请参阅 metaObject ().

宏文档编制

Q_CLASSINFO ( Name , Value )

此宏将额外信息关联到类，是可用的使用 QObject::metaObject (). Except for the ActiveQt extension, Qt doesn't use this information.

额外信息接受形式化的 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 ().

Q_DISABLE_COPY ( Class )

禁用拷贝构造函数和赋值运算符的使用为给定 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 .

Q_EMIT

使用此宏替换 emit 关键词对于发射信号，当想要使用 Qt 信号和槽采用第 3 方信号/槽机制 .

通常使用宏当 no_keywords 的指定是采用 CONFIG 变量在 .pro 文件，但可以使用它甚至在 no_keywords is not 指定。

Q_ENUMS (...)

This macro registers one or several enum types to the meta-object system.

例如：

class MyClass : public QObject
{
    Q_OBJECT
    Q_ENUMS(Priority)
public:
    MyClass(QObject *parent = 0);
    ~MyClass();
    enum Priority { High, Low, VeryHigh, VeryLow };
    void setPriority(Priority priority);
    Priority priority() const;
};

If you want to register an enum that is declared in another class, the enum must be fully qualified with the name of the class defining it. In addition, the class defining the enum has to inherit QObject as well as declare the enum using Q_ENUMS().

另请参阅 Qt 的特性系统 .

Q_FLAGS (...)

This macro registers one or several flags types to the meta-object system. It is typically used in a class definition to declare that values of a given enum can be used as flags and combined using the bitwise OR operator.

例如，在 QLibrary ， LoadHints 标志的声明方式如下：

class QLibrary : public QObject
{
    ...
    Q_FLAGS(LoadHint LoadHints)
    ...

标志自身声明的履行是在公共部分 QLibrary 类本身，使用 Q_DECLARE_FLAGS () 宏：

    ...
public:
    enum LoadHint {
        ResolveAllSymbolsHint = 0x01,
        ExportExternalSymbolsHint = 0x02,
        LoadArchiveMemberHint = 0x04
    };
    Q_DECLARE_FLAGS(LoadHints, LoadHint)
    ...

注意： This macro takes care of registering individual flag values with the meta-object system, so it is unnecessary to use Q_ENUMS () 除此宏外。

另请参阅 Qt 的特性系统 .

Q_INTERFACES (...)

此宏告诉 Qt 类实现哪些接口。使用这当实现插件时。

范例：

class BasicToolsPlugin : public QObject,
                         public BrushInterface,
                         public ShapeInterface,
                         public FilterInterface
{
    Q_OBJECT
    Q_INTERFACES(BrushInterface ShapeInterface FilterInterface)
public:
    ...
};

见插件和描绘基本工具范例了解细节。

另请参阅 Q_DECLARE_INTERFACE (), Q_EXPORT_PLUGIN2 ()，和如何创建 Qt 插件 .

Q_INVOKABLE

Apply this macro to definitions of member functions to allow them to be invoked via the meta-object system. The macro is written before the return type, as shown in the following example:

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

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 . Use Q_GADGET instead of Q_OBJECT to enable the meta object system's support for enums in a class that is not a QObject subclass. Q_GADGET makes a class member, staticMetaObject ，可用。 staticMetaObject 是类型 QMetaObject 并提供对枚举的访问声明采用 Q_ENUMS . Q_GADGET is provided only for C++.

另请参阅 元对象系统 , 信号和槽，和 Qt 的特性系统 .

Q_PROPERTY (...)

此宏用于声明类特性，当继承 QObject 。特性的行为像类数据成员，但它们拥有的额外特征可访问透过元对象系统 .

Q_PROPERTY(type name
           READ getFunction
           [WRITE setFunction]
           [RESET resetFunction]
           [NOTIFY notifySignal]
           [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 的特性系统 .

Q_SIGNAL

这是允许将单个函数，标记为信号的额外宏。它可能非常有用，尤其是当使用第 3 方源代码剖析器不理解 signals or Q_SIGNALS 组。

使用此宏替换 signals 关键词在类声明中，当想要使用 Qt 信号和槽采用第 3 方信号/槽机制 .

通常使用宏当 no_keywords 的指定是采用 CONFIG 变量在 .pro 文件，但可以使用它甚至在 no_keywords is not 指定。

Q_SIGNALS

使用此宏替换 signals 关键词在类声明中，当想要使用 Qt 信号和槽采用第 3 方信号/槽机制 .

通常使用宏当 no_keywords 的指定是采用 CONFIG 变量在 .pro 文件，但可以使用它甚至在 no_keywords is not 指定。

Q_SLOT

这是允许将单个函数，标记为槽的额外宏。它可能非常有用，尤其是当使用第 3 方源代码剖析器不理解 slots or Q_SLOTS 组。

使用此宏替换 slots 关键词在类声明中，当想要使用 Qt 信号和槽采用第 3 方信号/槽机制 .

通常使用宏当 no_keywords 的指定是采用 CONFIG 变量在 .pro 文件，但可以使用它甚至在 no_keywords is not 指定。

Q_SLOTS

使用此宏替换 slots 关键词在类声明中，当想要使用 Qt 信号和槽采用第 3 方信号/槽机制 .

通常使用宏当 no_keywords 的指定是采用 CONFIG 变量在 .pro 文件，但可以使用它甚至在 no_keywords is not 指定。

内容

QObject 类

特性

公共函数

公共槽

信号

静态公共成员

保护函数

相关非成员

宏

详细描述

线程亲缘关系

No copy constructor or assignment operator

自动连接

动态特性

国际化 (i18n)

特性文档编制

objectName : QString

成员函数文档编制

QObject:: QObject ( QObject * parent = 0)

[虚拟] QObject:: ~QObject ()

bool QObject:: blockSignals ( bool block )

[virtual protected] void QObject:: childEvent ( QChildEvent * event )

const QObjectList & QObject:: children () const

[static] bool QObject:: connect (const QObject * sender , const char * signal , const QObject * receiver , const char * method , Qt::ConnectionType type = Qt::AutoConnection)

[static] bool QObject:: connect (const QObject * sender , const QMetaMethod & signal , const QObject * receiver , const QMetaMethod & method , Qt::ConnectionType type = Qt::AutoConnection)

bool QObject:: connect (const QObject * sender , const char * signal , const char * method , Qt::ConnectionType type = Qt::AutoConnection) const

[virtual protected] void QObject:: connectNotify (const char * signal )

[virtual protected] void QObject:: customEvent ( QEvent * event )

[slot] void QObject:: deleteLater ()

[signal] void QObject:: destroyed ( QObject * obj = 0)

[static] bool QObject:: disconnect (const QObject * sender , const char * signal , const QObject * receiver , const char * method )

[static] bool QObject:: disconnect (const QObject * sender , const QMetaMethod & signal , const QObject * receiver , const QMetaMethod & method )

bool QObject:: disconnect (const char * signal = 0, const QObject * receiver = 0, const char * method = 0)

bool QObject:: disconnect (const QObject * receiver , const char * method = 0)

[virtual protected] void QObject:: disconnectNotify (const char * signal )

void QObject:: dumpObjectInfo ()

void QObject:: dumpObjectTree ()

QList < QByteArray > QObject:: dynamicPropertyNames () const

[虚拟] bool QObject:: event ( QEvent * e )

[虚拟] bool QObject:: eventFilter ( QObject * watched , QEvent * event )

T QObject:: findChild (const QString & name = QString()) const

QList < T > QObject:: findChildren (const QString & name = QString()) const

QList < T > QObject:: findChildren (const QRegExp & regExp ) const

bool QObject:: inherits (const char * className ) const

void QObject:: installEventFilter ( QObject * filterObj )

bool QObject:: isWidgetType () const

void QObject:: killTimer ( int id )

[虚拟] const QMetaObject * QObject:: metaObject () const

void QObject:: moveToThread ( QThread * targetThread )

QObject * QObject:: parent () const

QVariant QObject:: property (const char * name ) const

[protected] int QObject:: receivers (const char * signal ) const

void QObject:: removeEventFilter ( QObject * obj )

[protected] QObject * QObject:: sender () const

[protected] int QObject:: senderSignalIndex () const

void QObject:: setParent ( QObject * parent )

bool QObject:: setProperty (const char * name , const QVariant & value )

bool QObject:: signalsBlocked () const

int QObject:: startTimer ( int interval )

QThread * QObject:: thread () const

[virtual protected] void QObject:: timerEvent ( QTimerEvent * event )

[static] QString QObject:: tr (const char * sourceText , const char * disambiguation = 0, int n = -1)

[static] QString QObject:: trUtf8 (const char * sourceText , const char * disambiguation = 0, int n = -1)

成员变量文档编制

const QMetaObject QObject:: staticMetaObject

相关非成员

typedef QObjectList

QList < T > qFindChildren (const QObject * obj , const QRegExp & regExp )

T qobject_cast ( QObject * object )

宏文档编制

Q_CLASSINFO ( Name , Value )

Q_DISABLE_COPY ( Class )

Q_EMIT

Q_ENUMS (...)

Q_FLAGS (...)

Q_INTERFACES (...)

Q_INVOKABLE

Q_OBJECT

Q_PROPERTY (...)

`[虚拟]` QObject:: ~QObject ()

`[virtual protected]` void QObject:: childEvent ( QChildEvent * event )

`[static]` bool QObject:: connect (const QObject * sender , const char * signal , const QObject * receiver , const char * method , Qt::ConnectionType type = Qt::AutoConnection)

`[static]` bool QObject:: connect (const QObject * sender , const QMetaMethod & signal , const QObject * receiver , const QMetaMethod & method , Qt::ConnectionType type = Qt::AutoConnection)

`[virtual protected]` void QObject:: connectNotify (const char * signal )

`[virtual protected]` void QObject:: customEvent ( QEvent * event )

`[slot]` void QObject:: deleteLater ()

`[signal]` void QObject:: destroyed ( QObject * obj = 0)

`[static]` bool QObject:: disconnect (const QObject * sender , const char * signal , const QObject * receiver , const char * method )

`[static]` bool QObject:: disconnect (const QObject * sender , const QMetaMethod & signal , const QObject * receiver , const QMetaMethod & method )

`[virtual protected]` void QObject:: disconnectNotify (const char * signal )

`[虚拟]` bool QObject:: event ( QEvent * e )

`[虚拟]` bool QObject:: eventFilter ( QObject * watched , QEvent * event )

`[虚拟]` const QMetaObject * QObject:: metaObject () const

`[protected]` int QObject:: receivers (const char * signal ) const

`[protected]` QObject * QObject:: sender () const

`[protected]` int QObject:: senderSignalIndex () const

`[virtual protected]` void QObject:: timerEvent ( QTimerEvent * event )

`[static]` QString QObject:: tr (const char * sourceText , const char * disambiguation = 0, int n = -1)

`[static]` QString QObject:: trUtf8 (const char * sourceText , const char * disambiguation = 0, int n = -1)