就業培訓     下載中心     Wiki     聯絡
登錄   注冊
  1. 首頁
  2. Qt 5.12.12
  3. Qt Core
  4. C++ 類
  5. QObject

內容

QObject 類

The QObject 類是所有 Qt 對象的基類。 更多...

頭： #include <QObject>
qmake: QT += core
繼承者： QAbstractAnimation , QAbstractEventDispatcher , QAbstractItemModel , QAbstractState , QAbstractTransition , QCoreApplication , QEventLoop , QFileSelector , QFileSystemWatcher , QIODevice , QItemSelectionModel , QLibrary , QMimeData , QObjectCleanupHandler , QPluginLoader , QSettings , QSharedMemory , QSignalMapper , QSocketNotifier , QThread , QThreadPool , QTimeLine , QTimer , QTranslator ，和 QWinEventNotifier

注意： 此類的所有函數 可重入 .

注意： 這些函數也是 綫程安全 :

  • connect (const QObject *sender, const char *signal, const QObject *receiver, const char *method, Qt::ConnectionType type)
  • connect (const QObject *sender, const char *signal, const char *method, Qt::ConnectionType type) const
  • connect (const QObject *sender, PointerToMemberFunction signal, const QObject *receiver, PointerToMemberFunction method, Qt::ConnectionType type)
  • connect (const QObject *sender, PointerToMemberFunction signal, Functor functor)
  • connect (const QObject *sender, PointerToMemberFunction signal, const QObject *context, Functor functor, Qt::ConnectionType type)
  • disconnect (const QObject *sender, const char *signal, const QObject *receiver, const char *method)
  • disconnect (const char *signal, const QObject *receiver, const char *method) const
  • disconnect (const QObject *sender, PointerToMemberFunction signal, const QObject *receiver, PointerToMemberFunction method)
  • deleteLater ()

特性

公共函數

QObject (QObject * parent = 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 = nullptr, const QObject * receiver = nullptr, const char * method = nullptr) const
bool disconnect (const QObject * receiver , const char * method = 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 = 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_OBJECT, int n = Q_OBJECT)

保護函數

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 )

保護變量

QScopedPointer<QObjectData> d_ptr

靜態保護成員

const QMetaObject staticQtMetaObject
typedef QObjectList
QList<T> qFindChildren (const QObject * obj , const QRegExp & regExp )
T qobject_cast (QObject * object )
T qobject_cast (const 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_NAMESPACE
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 和用戶創建的錶單兩者都可以賦予動態特性。

國際化 (I18n)

所有 QObject 子類都支持 Qt 翻譯特徵，使之可能將應用程序用戶界麵翻譯成不同語言。

為使對用戶可見的文本可翻譯，必須將它包裹在調用 tr () 函數。這的詳細解釋在 編寫翻譯源代碼 文檔。

另請參閱 QMetaObject , QPointer , QObjectCleanupHandler , Q_DISABLE_COPY ()，和 對象樹 & 所有權 .

特性文檔編製

objectName : QString

此特性保持該對象的名稱

可按名稱 (和類型) 查找對象，使用 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 ().

成員函數文檔編製

QObject:: QObject ( QObject * parent = nullptr)

構造對象采用父級對象 parent .

對象的父級可以被視為對象的所有者。例如， 對話框 是父級對於 OK and Cancel 按鈕 (它包含的)。

父級對象的析構函數會銷毀所有子級對象。

設置 parent 為 0 構造沒有父級的對象。若對象是 Widget，它將變為頂層窗口。

注意： 此函數可以被援引，通過元對象係統和從 QML。見 Q_INVOKABLE .

另請參閱 parent (), findChild ()，和 findChildren ().

[虛擬] QObject:: ~QObject ()

銷毀對象，刪除其所有子級對象。

自動斷開到/自對象的所有信號連接，並從事件隊列移除對象的任何待決張貼事件。不管怎樣，經常更安全使用 deleteLater () 而不是刪除 QObject 子類直接。

警告： 刪除所有子級對象。若這些對象中的任一在堆棧 (或全局) 中，程序遲早會崩潰。不推薦從父級外部保持子級對象的指針。若仍然這樣做， destroyed () 信號給予機會以檢測對象何時被銷毀。

警告： 刪除 QObject 當等待交付的待決事件會導緻崩潰時。不得刪除 QObject 直接，若它存在於目前執行綫程的不同綫程中。使用 deleteLater () 代替，將導緻事件循環刪除對象在所有待決事件被交付給對象之後。

另請參閱 deleteLater ().

bool QObject:: blockSignals ( bool block )

若 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 ().

const QObjectList &QObject:: children () const

返迴子級對象的列錶。 QObjectList 類的定義在 <QObject> 頭文件，如下所示： 

typedef QList<QObject*> QObjectList;

第 1 添加子級是 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 () 以注冊數據類型在建立連接之前。

注意： 此函數是 綫程安全 .

另請參閱 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).

QMetaObject::Connection 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 ().

注意： 此函數是 綫程安全 .

另請參閱 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 .

注意： 此函數是 綫程安全 .

另請參閱 基於字符串的連接和基於函子的連接之間的差異 .

[static] QMetaObject::Connection QObject:: connect (const QObject * sender , PointerToMemberFunction signal , Functor functor )

此函數重載 connect ().

創建連接從 signal in sender 對象到 functor ，並返迴要連接的句柄

信號必須是 Header (頭) 中被聲明成信號的函數。槽函數可以是，能連接到信號的任何函數 (或函子)。函數可以連接到給定信號，若信號擁有至少如槽一樣多的自變量。函子可以連接到信號，若它們擁有準確相同數量的自變量。信號和槽中的相應自變量類型之間，必須存在隱式轉換。

範例： 

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 .

注意： 此函數是 綫程安全 .

[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、非成員函數及函子；它們僅適用於連接到成員函數。

信號必須是 Header (頭) 中被聲明成信號的函數。槽函數可以是，能連接到信號的任何函數 (或函子)。函數可以連接到給定信號，若信號擁有至少如槽一樣多的自變量。函子可以連接到信號，若它們擁有準確相同數量的自變量。信號和槽中的相應自變量類型之間，必須存在隱式轉換。

範例： 

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 .

注意： 此函數是 綫程安全 .

該函數在 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 參數。

另請參閱 event () 和 QEvent .

[slot] void QObject:: deleteLater ()

調度刪除此對象。

將刪除對象，當控製返迴給事件循環時。若事件循環未運行，當調用此函數時 (如，對象調用 deleteLater() 先於 QCoreApplication::exec ())，會刪除對象，一旦啓動事件循環。若在 main 事件循環已停止後調用 deleteLater()，就不會刪除對象。從 Qt 4.8 起，若活在未運行事件循環綫程中的對象調用 deleteLater()，就不會銷毀對象當綫程完成時。

注意：進入和離開新事件循環 (如，通過打開模態對話框) 會 not 履行延遲刪除；對於要被刪除的對象而言，控製必須返迴給調用 deleteLater() 的事件循環。這不適用於嵌套事件循環仍在運行，先前被刪除的對象：新嵌套事件循環一開始，Qt 事件循環就會盡快刪除這些對象。

注意： 多次調用此函數是安全的；當交付首個延遲刪除事件時，會從事件隊列移除對象的任何待決事件。

注意： 此函數是 綫程安全 .

另請參閱 destroyed () 和 QPointer .

[signal] void QObject:: destroyed ( QObject * obj = 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 種方式使用。

  1. 斷開連接到對象信號的一切： 
    disconnect(myObject, 0, 0, 0);

    相當於非靜態重載函數 

    myObject->disconnect();
  2. 斷開連接到特定信號的一切： 
    disconnect(myObject, SIGNAL(mySignal()), 0, 0);

    相當於非靜態重載函數 

    myObject->disconnect(SIGNAL(mySignal()));
  3. 斷開特定接收者的連接： 
    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 被省略，所以無法斷開連接所有對象中的具體命名槽。

注意： 此函數是 綫程安全 .

另請參閱 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:

  1. signal 不是發送者類成員 (或其父級類成員)。
  2. method 不是接收者類成員 (或其父級類成員)。
  3. 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 = nullptr, const QObject * receiver = nullptr, const char * method = nullptr) const

此函數重載 disconnect ().

斷開連接 signal from method of receiver .

信號/槽連接被移除，當涉及的對象被銷毀時。

注意： 此函數是 綫程安全 .

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

此函數重載 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 種方式使用。

  1. 斷開連接到對象信號的一切： 
    disconnect(myObject, 0, 0, 0);
  2. 斷開連接到特定信號的一切： 
    disconnect(myObject, &MyObject::mySignal(), 0, 0);
  3. 斷開特定接收者的連接： 
    disconnect(myObject, 0, myReceiver, 0);
  4. 斷開從特定信號到特定槽的連接： 
    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

注意： 此函數是 綫程安全 .

另請參閱 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 ().

void QObject:: dumpObjectInfo () const

將有關此對象的信號連接等信息轉儲到調試輸齣。

注意： 在 Qt 5.9 之前，此函數不是 const。

另請參閱 dumpObjectTree ().

void QObject:: dumpObjectTree () const

將子級樹轉儲到調試輸齣。

注意： 在 Qt 5.9 之前，此函數不是 const。

另請參閱 dumpObjectInfo ().

QList < QByteArray > QObject:: dynamicPropertyNames () const

返迴被動態添加到對象的所有特性的名稱，使用 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) override
    {
        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) override;
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()。

某些事件，譬如 QEvent::ShortcutOverride 必須被明確接受 (通過調用 accept() 對於它們) 為阻止傳播。

警告： 若在此函數中刪除接收者對象，確保返迴 true。否則，Qt 將把事件轉發給被刪除對象，且程序可能崩潰。

另請參閱 installEventFilter ().

T QObject:: findChild (const QString & name = QString(), Qt::FindChildOptions options = Qt::FindChildrenRecursively) const

返迴此對象的子級可以被鑄造成 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 ().

QList < T > QObject:: findChildren (const QString & name = QString(), Qt::FindChildOptions options = Qt::FindChildrenRecursively) const

返迴此對象的所有子級具有給定 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 ().

QList < T > QObject:: findChildren (const QRegExp & regExp , Qt::FindChildOptions options = Qt::FindChildrenRecursively) const

此函數重載 findChildren ().

返迴此對象的子級，可以被鑄造成 T 類型且擁有的名稱匹配正則錶達式 regExp ，或空列錶若沒有這種對象。遞歸履行搜索，除非 options 指定 FindDirectChildrenOnly 選項。

QList < T > QObject:: findChildren (const QRegularExpression & re , Qt::FindChildOptions options = Qt::FindChildrenRecursively) const

此函數重載 findChildren ().

返迴此對象的子級，可以被鑄造成 T 類型且擁有的名稱匹配正則錶達式 re ，或空列錶若沒有這種對象。遞歸履行搜索，除非 options 指定 FindDirectChildrenOnly 選項。

該函數在 Qt 5.0 引入。

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

返迴 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 ().

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) override;
};
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 被連接到至少 1 接收者，否則返迴 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 引入。

bool QObject:: isWidgetType () const

返迴 true 若對象是 Widget；否則返迴 false .

調用此函數相當於調用 inherits("QWidget") ，除瞭它更快。

bool QObject:: isWindowType () const

返迴 true 若對象是窗口；否則返迴 false .

調用此函數相當於調用 inherits("QWindow") ，除瞭它更快。

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 .

To move an object to the main thread, use QApplication::instance() to retrieve a pointer to the current application, and then use QApplication::thread() to retrieve the thread in which the application lives. For example: 

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

若 targetThread is nullptr ，此對象及其子級的所有事件處理停止，因為它們不再關聯任何綫程。

注意，對象的所有活動計時器都將被重置。計時器先在當前綫程中停止並重啓 (采用相同間隔) 在 targetThread 。因此，在綫程之間不斷移動對象可以無限期推遲計時器事件。

A QEvent::ThreadChange 事件被發送給此對象，恰好在改變綫程親緣關係之前。可以處理此事件以履行任何特殊處理。注意，張貼給此對象的任何新事件都將被處理在 targetThread , provided it is non-null: when it is nullptr ，此對象或其子級的事件處理不會發生，因為它們不再關聯任何綫程。

警告： 此函數是 not 綫程安全的；當前綫程的親緣關係必須如當前綫程一樣。換句話說，此函數隻可以把對象從當前綫程 Push (壓入) 到另一綫程，無法將對象從任意綫程 Pull (拉齣) 到當前綫程。不管怎樣，此規則有一種例外：可以將沒有綫程親緣關係的對象 Pull (拉齣) 到當前綫程。

另請參閱 thread ().

[signal] void QObject:: objectNameChanged (const QString & objectName )

此信號發射，在對象名稱改變後。傳遞新對象名稱按 objectName .

注意： 這是私有信號。它可以用於信號連接，但不能由用戶發射。

注意： 通知程序信號對於特性 objectName .

另請參閱 QObject::objectName .

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);
}

警告： 此函數違反瞭麵嚮對象的模塊化原則。不管怎樣，它可能很有用僅當某些東西連接到信號時，纔需要履行昂貴的初始化。

另請參閱 isSignalConnected ().

void QObject:: removeEventFilter ( QObject * obj )

移除事件過濾器對象 obj 從此對象。忽略請求，若尚未安裝這種事件過濾器。

將自動移除此對象的所有事件過濾器，當此對象被銷毀時。

它始終安全地移除事件過濾器，即使在事件過濾器激活期間 (即：從 eventFilter () 函數)。

另請參閱 installEventFilter (), eventFilter ()，和 event ().

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

返迴發送信號的對象指針，若在由信號激活的槽中調用；否則它返迴 nullptr 。指針纔有效，在從此對象綫程上下文調用此函數的槽執行期間。

由此函數返迴的指針變為無效若發送者被銷毀，或者，若槽斷開連接發送者信號。

警告： 此函數違反瞭麵嚮對象的模塊化原則。不管怎樣，訪問發送者可能很有用，當多個信號連接到單個槽時。

警告： 如上所述，此函數的返迴值無效，當槽被調用憑藉 Qt::DirectConnection 來自不同於此對象綫程的綫程。不要在這種情景類型下使用此函數。

另請參閱 senderSignalIndex ().

[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 () 和 children ().

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 ()，和 QMetaProperty::write ().

bool QObject:: signalsBlocked () const

返迴 true 若信號被阻塞；否則返迴 false .

信號不被阻塞，默認情況下。

另請參閱 blockSignals () 和 QSignalBlocker .

int QObject:: startTimer ( int interval , Qt::TimerType timerType = Qt::CoarseTimer)

啓動計時器並返迴計時器標識符，或返迴 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) override;
};
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 ().

int QObject:: startTimer ( std::chrono::milliseconds time , Qt::TimerType timerType = Qt::CoarseTimer)

這是重載函數。

啓動計時器並返迴計時器標識符，或返迴 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) override;
};
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 ().

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 = Q_OBJECT, int n = Q_OBJECT)

返迴翻譯版本的 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 國際化 .

成員變量文檔編製

const QMetaObject QObject:: staticMetaObject

此變量存儲類的元對象。

元對象包含的信息有關類繼承 QObject ，如類名、超類名、特性、信號及槽。每個類包含 Q_OBJECT 宏也將擁有元對象。

元對象信息是信號/槽連接機製和特性係統要求的。 inherits () 函數還利用瞭元對象。

若擁有指嚮對象的指針，可以使用 metaObject () 以檢索該對象關聯的元對象。

範例： 

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

另請參閱 metaObject ().

相關非成員

T qobject_cast ( QObject * object )

T qobject_cast (const QObject * object )

返迴給定 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

The qobject_cast () 函數行為類似於標準 C++ dynamic_cast() ，它的優點是不要求 RTTI 支持，且跨動態庫邊界工作。

qobject_cast () 也可以與接口結閤使用；見 插件和描繪 範例瞭解細節。

警告： 若 T 未被聲明采用 Q_OBJECT 宏，此函數的返迴值是不確定的。

另請參閱 QObject::inherits ().

typedef QObjectList

同義詞 QList < QObject *>.

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

此函數重載 qFindChildren()。

此函數相當於 obj -> findChildren <T>( regExp ).

注意： 此函數是為不支持成員模闆函數的 MSVC 6 提供的解決方案。建議在新代碼中使用其它形式。

另請參閱 QObject::findChildren ().

T qobject_cast ( QObject * object )

T qobject_cast (const QObject * object )

宏文檔編製

QT_NO_NARROWING_CONVERSIONS_IN_CONNECT

定義此宏將禁用由信號攜帶的自變量與由槽接受的自變量之間的窄化和浮點到整型的轉換，當使用基於 PMF 的句法連接信號和槽時。

該函數在 Qt 5.8 引入。

另請參閱 QObject::connect .

Q_CLASSINFO ( Name , Value )

此宏將額外信息關聯到類，是可用的使用 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 .

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 &) = delete;
    MyClass &operator=(const MyClass &) = delete;
};

即使這樣，也絕對不可能捕獲每種情況。可能被誘惑做像這樣的一些事： 

QWidget w = QWidget();

首先，不要這樣做。大多數編譯器將生成使用拷貝構造函數的代碼，所以會報告違反隱私錯誤，但不要求 C++ 編譯器以特定方式為該語句生成代碼。可以生成代碼使用 neither 拷貝構造函數 nor 私有賦值運算符。這種情況不會報錯，但應用程序可能崩潰當調用成員函數從 w .

Q_EMIT

使用此宏替換 發射 關鍵詞對於發射信號，當想要使用 Qt 信號和槽采用 第 3 方信號/槽機製 .

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

Q_ENUM ( ... )

此宏采用元對象係統注冊枚舉類型。它必須放在類枚舉聲明之後，類有 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 將打印齣它們的名稱。

記住，枚舉值被存儲成有符號 int 在元對象係統中。注冊枚舉具有的值在有效值範圍之外對於 int 將導緻溢齣和潛在未定義行為，當透過元對象係統訪問它們時。例如，QML 透過元對象係統訪問注冊的枚舉。

該函數在 Qt 5.5 引入。

另請參閱 Qt 的特性係統 .

Q_ENUM_NS ( ... )

此宏嚮元對象係統注冊枚舉類型。必須將它放在枚舉聲明後若命名空間中有 Q_NAMESPACE 宏。如同 Q_ENUM 但在名稱空間中。

采用 Q_ENUM_NS 聲明的枚舉有自已的 QMetaEnum 注冊在封閉 QMetaObject 。還可以使用 QMetaEnum::fromType () 以獲取 QMetaEnum .

已注冊枚舉也會自動注冊到 Qt 元類型係統，以使它們知道 QMetaType 無需使用 Q_DECLARE_METATYPE ()。這將啓用有用特徵；例如，若用於 QVariant ，可以將它們轉換成字符串。同樣，將它們傳遞給 QDebug 將打印齣它們的名稱。

記住，枚舉值被存儲成有符號 int 在元對象係統中。注冊枚舉具有的值在有效值範圍之外對於 int 將導緻溢齣和潛在未定義行為，當透過元對象係統訪問它們時。例如，QML 透過元對象係統訪問注冊的枚舉。

該函數在 Qt 5.8 引入。

另請參閱 Qt 的特性係統 .

Q_FLAG ( ... )

此宏注冊單 標誌類型 采用元對象係統。通常用於類定義，以聲明可以用作標誌的給定枚舉值，並使用按位 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 的特性係統 .

Q_FLAG_NS ( ... )

此宏注冊單 標誌類型 采用元對象係統。它用於的名稱空間擁有 Q_NAMESPACE 宏，以聲明可以用作標誌的給定枚舉值，並使用按位 OR 運算符組閤。如同 Q_FLAG 但在名稱空間中。

宏必須放在枚舉聲明後。

注意： Q_FLAG_NS 宏負責采用元對象係統注冊單個標誌值，因此不必使用 Q_ENUM_NS () 除此宏外。

該函數在 Qt 5.8 引入。

另請參閱 Qt 的特性係統 .

Q_GADGET

Q_GADGET 宏是更輕版本的 Q_OBJECT 宏，對於類不繼承 QObject 但仍想使用某些反射能力提供通過 QMetaObject 。就像 Q_OBJECT 宏，它必須齣現在類定義私有區間。

Q_GADGET 可以擁有 Q_ENUM , Q_PROPERTY and Q_INVOKABLE ，但它們無法擁有信號或槽。

Q_GADGET 使類成員， staticMetaObject ，可用。 staticMetaObject 是類型 QMetaObject 並提供對采用 Q_ENUMS 聲明枚舉的訪問。

Q_INTERFACES ( ... )

此宏告訴 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 插件 .

Q_INVOKABLE

將此宏應用於成員函數聲明，以允許憑藉元對象係統援引它們。宏寫在返迴類型之前，如以下範例所示： 

class Window : public QWidget
{
    Q_OBJECT
public:
    Window();
    void normalMethod();
    Q_INVOKABLE void invokableMethod();
};

The invokableMethod() 函數使用 Q_INVOKABLE 進行標記，導緻它嚮元對象係統注冊並使其能夠被援引使用 QMetaObject::invokeMethod ()。由於 normalMethod() 函數未按此方式注冊，不可以援引它使用 QMetaObject::invokeMethod ().

若可援引成員函數返迴的指針指嚮 QObject 或子類化的 QObject 且是從 QML 援引它的，適用特殊的所有權規則。見 在 QML 和 C++ 之間的數據類型轉換 瞭解更多信息。

Q_NAMESPACE

Q_NAMESPACE 宏可以用於添加 QMetaObject 能力到名稱空間。

Q_NAMESPACE 可以擁有 Q_CLASSINFO , Q_ENUM_NS , Q_FLAG_NS ，但它們不可以擁有 Q_ENUM , Q_FLAG , Q_PROPERTY , Q_INVOKABLE ，信號或槽。

Q_NAMESPACE 製作外部變量， staticMetaObject ，可用。 staticMetaObject 是類型 QMetaObject 並提供對枚舉的訪問聲明采用 Q_ENUM_NS / Q_FLAG_NS .

該函數在 Qt 5.8 引入。

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 。使用 Q_GADGET 而不是 Q_OBJECT 來啓用元對象係統類枚舉支持，不要求是 QObject 子類。

另請參閱 元對象係統 , 信號和槽 ，和 Qt 的特性係統 .

Q_PROPERTY ( ... )

此宏用於聲明類特性，當繼承 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 的特性係統 .

Q_REVISION

將此宏應用到成員函數聲明，以在元對象係統中采用修訂號標記它們。宏寫在返迴類型之前，如以下範例所示： 

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 ().

Q_SET_OBJECT_NAME ( Object )

此宏賦值 Object 對象名 Object。

它不管是否 Object 是指針或不是指針，宏自己會弄清楚。

該函數在 Qt 5.0 引入。

另請參閱 QObject::objectName ().

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 指定。