QObject Class

メンバ関数のドキュメント

[explicit invokable] QObject::QObject(QObject *parent = nullptr)

親オブジェクトparent を持つオブジェクトを生成します。

オブジェクトの親は、そのオブジェクトの所有者と見なすことができます。たとえば、dialog box は、そこに含まれるOK およびCancel ボタンの親となります。

親オブジェクトのデストラクタは、すべての子オブジェクトを破棄します。

parent をnullptr に設定すると、親を持たないオブジェクトが構築されます。そのオブジェクトがウィジェットである場合、トップレベルのウィンドウとなります。

parent()、findChild()、およびfindChildren()も参照してください 。

[virtual noexcept] QObject::~QObject()

オブジェクトを破棄し、そのすべての子オブジェクトを削除します。

そのオブジェクトとの間で送受信されていたすべてのシグナルは自動的に切断され、そのオブジェクトに対して保留中の投稿済みイベントはイベントキューから削除されます。ただし、QObject のサブクラスを直接削除するよりも、deleteLater()を使用する方が安全な場合が多いです。

deleteLater()も参照してください 。

[noexcept] bool QObject::blockSignals(bool block)

block がtrueの場合、このオブジェクトから発信されるシグナルはブロックされます（つまり、シグナルを発信しても、それに接続されているものは何も呼び出されません）。block がfalseの場合、そのようなブロックは発生しません。

戻り値は、signalsBlocked() の直前の値です。

なお、このオブジェクトのシグナルがブロックされている場合でも、destroyed() シグナルは発信されます。

ブロックされている間に発行されたシグナルはバッファリングされません。

signalsBlocked() およびQSignalBlockerも参照してください 。

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

このイベントハンドラは、子イベントを受け取るためにサブクラスで再実装することができます。イベントはevent パラメータを通じて渡されます。

QEvent::ChildAdded また、QEvent::ChildRemoved イベントは、子ウィジェットが追加または削除された際にオブジェクトに送信されます。いずれの場合も、その子ウィジェットがQObject であるか、あるいはisWidgetType()がtrue を返す場合はQWidget であることにのみ依存できます。（これは、ChildAdded の場合、子ウィジェットがまだ完全に構築されていないためであり、ChildRemoved の場合、すでに破棄されている可能性があるためです）。

QEvent::ChildPolished イベントは、子ウィジェットがpolished状態になったとき、またはpolished状態の子ウィジェットが追加されたときにウィジェットに送信されます。子ウィジェットのpolishedイベントを受信した場合、通常はその子ウィジェットの構築は完了しています。ただし、これは保証されるものではなく、ウィジェットのコンストラクタの実行中に複数のpolishedイベントが配信される可能性があります。

子ウィジェットごとに、1つのChildAdded イベント、0個以上のChildPolished イベント、および1つのChildRemoved イベントを受信します。

子ウィジェットが追加された直後に削除された場合、ChildPolished イベントは発生しません。構築および破棄の過程で子ウィジェットが複数回ポリッシュ処理された場合、同じ子ウィジェットに対して複数のchild polishedイベントが受信される可能性があり、その都度異なる仮想テーブルが使用されます。

event()も参照してください 。

const QObjectList &QObject::children() const

子オブジェクトのリストを返します。QObjectList クラスは、<QObject> ヘッダーファイル内で次のように定義されています。

typedef QList<QObject*> QObjectList;

最初に追加された子オブジェクトはリスト内の `first ` オブジェクトとなり、最後に追加された子オブジェクトはリスト内の `last ` オブジェクトとなります。つまり、新しい子オブジェクトはリストの末尾に追加されます。

なお、QWidget の子要素がraised またはlowered である場合、リストの順序が変化することに注意してください。リスト内で上位に移動したウィジェットはリストの最後のオブジェクトとなり、下位に移動したウィジェットはリストの最初のオブジェクトとなります。

findChild()、findChildren()、parent()、およびsetParent()も参照してください 。

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

sender オブジェクト内のsignal から、receiver オブジェクト内のmethod への、指定されたtype の接続を作成します。後で接続を切断するために使用できる、その接続へのハンドルを返します。

接続を作成できない場合（たとえば、パラメータが無効な場合など）、Connectionハンドルは無効になります。QMetaObject::Connection が有効かどうかは、bool型にキャストすることで確認できます。

この関数はconnect(const QObject *sender, const char *signal, const QObject *receiver, const char *method, Qt::ConnectionType type) と同様に動作しますが、シグナルとメソッドを指定するためにQMetaMethod を使用します。

connect(const QObject *sender, const char *signal, const QObject *receiver, const char *method, Qt::ConnectionType type)も参照してください。

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

sender オブジェクト内のsignal にある指定されたtype と、receiver オブジェクト内のmethod との接続を作成します。後で接続を切断するために使用できる、その接続へのハンドルを返します。

signal およびmethod を指定する際は、SIGNAL() およびSLOT() マクロを使用する必要があります。例：

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 に関連する名前で利用可能にしています。

1つのシグナルは、複数のスロットやシグナルに接続できます。また、1つのスロットには複数のシグナルを接続できます。

シグナルが複数のスロットに接続されている場合、シグナルが発信されると、接続が行われた順序と同じ順序でスロットがアクティブ化されます。

この関数は、シグナルとスロットの接続に成功した場合、接続へのハンドルを表す `QMetaObject::Connection ` を返します。接続を作成できない場合（例えば、QObject が `signal ` または `method` のいずれかの存在を確認できない場合、あるいはそれらのシグネチャが互換性がない場合など）、接続ハンドルは無効になります。ハンドルを `bool` にキャストすることで、その有効性を確認できます。

デフォルトでは、接続を確立するたびに 1 つのシグナルが発行され、重複する接続がある場合は 2 つのシグナルが発行されます。disconnect() を 1 回呼び出すだけで、これらの接続をすべて切断できます。Qt::UniqueConnection type を渡すと、重複していない場合にのみ接続が確立されます。すでに重複（同じオブジェクト上のまったく同じスロットに対するまったく同じシグナル）が存在する場合、接続は失敗し、connectは無効なQMetaObject::Connection を返します。

オプションのtype パラメータは、確立する接続のタイプを指定します。具体的には、特定のシグナルがスロットに即座に配信されるか、それとも後で配信されるようキューに入れられるかを決定します。 シグナルがキューに入れられる場合、Qt は引数をコピーしてバックグラウンドでイベントに格納する必要があるため、パラメータは Qt のメタオブジェクトシステムで認識される型でなければなりません。キュー入り接続を使用しようとして、次のようなエラーメッセージが表示された場合は

QObject::connect: Cannot queue arguments of type 'MyType'
(Make sure 'MyType' is registered using qRegisterMetaType().)

接続を確立する前に、qRegisterMetaType() を呼び出してデータ型を登録してください。

注： この関数はスレッドセーフです。

関連項目： disconnect()、sender()、qRegisterMetaType()、Q_DECLARE_METATYPE()、および「文字列ベースの接続とファンクタベースの接続の違い」。

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

sender オブジェクト内のsignal からfunctor への接続を作成し、その接続へのハンドルを返します

シグナルは、ヘッダー内でシグナルとして宣言された関数でなければなりません。スロット関数は、そのシグナルに接続可能な任意の関数またはファンクタです。スロット関数は、そのシグナルの引数の数がスロット関数の引数の数以上である場合に、そのシグナルに接続できます。シグナルとスロットの対応する引数の型間には、暗黙の変換が存在する必要があります。

例：

void someFunction();
//...
void someOtherFunction()
{
    QPushButton *button = new QPushButton;
    QObject::connect(button, &QPushButton::clicked, someFunction);
}

ラムダ式も使用できます:

    QByteArray page = "...";
    QTcpSocket *socket = new QTcpSocket;
    socket->connectToHost("qt-project.org", 80);
    QObject::connect(socket, &QTcpSocket::connected, [=] () {
            socket->write("GET " + page + "\r\n");
        });

送信者が破棄されると、接続は自動的に切断されます。ただし、シグナルが発信される時点で、ファンクタ内で使用されるオブジェクトがすべて存続していることを確認する必要があります。

このため、レシーバー／コンテキストとしてQObject も受け取るconnect()のオーバーロードを使用することを推奨します。QT_NO_CONTEXTLESS_CONNECT マクロを定義することで、コンテキストなしのオーバーロードの使用を無効にすることができます。

オーバーロードされた関数は、qOverload を利用して解決できます。

注： この関数はスレッドセーフです。

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

sender オブジェクトのsignal を、このオブジェクトのmethod に接続します。

connect(sender,signal,this,method,type) と同等です。

接続を確立するたびにシグナルが1つ発信されるため、重複した接続では2つのシグナルが発信されます。disconnect() を使用して接続を切断できます。

注： この関数はスレッドセーフです。

disconnect()も参照してください 。

[static] template <typename PointerToMemberFunction, typename Functor> QMetaObject::Connection QObject::connect(const QObject *sender, PointerToMemberFunction signal, const QObject *context, Functor functor, Qt::ConnectionType type = Qt::AutoConnection)

sender オブジェクト内のsignal から、指定されたtype をfunctor に接続し、context の特定のイベントループに配置するとともに、その接続へのハンドルを返します。

シグナルは、ヘッダー内でシグナルとして宣言された関数でなければなりません。スロット関数は、そのシグナルに接続可能な任意の関数またはファンクタで構いません。スロット関数は、シグナルの引数の数がスロット関数の引数の数以上である場合に、そのシグナルに接続できます。また、シグナルとスロットの対応する引数の型間には、暗黙の変換が存在する必要があります。

例：

void someFunction();
//...
void someOtherFunction()
{
    QPushButton *button = new QPushButton;
    QObject::connect(button, &QPushButton::clicked, this, someFunction, Qt::QueuedConnection);
}

ラムダ式も使用できます:

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 を使用して解決できます。

注： この関数はスレッドセーフです。

[static] template <typename PointerToMemberFunction> QMetaObject::Connection QObject::connect(const QObject *sender, PointerToMemberFunction signal, const QObject *receiver, PointerToMemberFunction method, Qt::ConnectionType type = Qt::AutoConnection)

sender オブジェクト内のsignal から、receiver オブジェクト内のmethod への、指定されたtype の接続を作成します。後で接続を解除するために使用できる、その接続へのハンドルを返します。

シグナルは、ヘッダー内でシグナルとして宣言された関数でなければなりません。スロット関数は、そのシグナルに接続可能な任意のメンバ関数です。スロットは、シグナルの引数の数がスロットの引数の数以上であり、かつシグナルとスロットの対応する引数の型間に暗黙の変換が存在する場合に、そのシグナルに接続できます。

例：

QLabel *label = new QLabel;
QLineEdit *lineEdit = new QLineEdit;
QObject::connect(lineEdit, &QLineEdit::textChanged,
                label,  &QLabel::setText);

この例では、ラベルに常に現在のラインエディットのテキストが表示されるようにしています。

1つのシグナルは、複数のスロットやシグナルに接続できます。また、1つのスロットには複数のシグナルを接続できます。

シグナルが複数のスロットに接続されている場合、シグナルが発行された際、スロットは接続が行われた順序と同じ順序でアクティブ化されます。

この関数は、シグナルとスロットの接続に成功した場合、その接続へのハンドルを返します。接続を作成できない場合（例えば、QObject がsignal の存在を確認できない場合など）、接続ハンドルは無効になります（ がシグナルとして宣言されていない場合）。QMetaObject::Connection が有効かどうかは、それをbool型にキャストすることで確認できます。

デフォルトでは、接続を確立するたびにシグナルが1つ発信され、重複した接続がある場合は2つのシグナルが発信されます。disconnect() を1回呼び出すだけで、これらの接続をすべて解除できます。Qt::UniqueConnection type を渡した場合、重複していない場合にのみ接続が確立されます。すでに重複（同じオブジェクト上のまったく同じスロットへのまったく同じシグナル）が存在する場合、接続は失敗し、connectは無効なQMetaObject::Connection を返します。

オプションのtype パラメータは、確立する接続のタイプを指定します。具体的には、特定のシグナルをスロットに即座に配信するか、後で配信されるようキューに入れるかを決定します。 シグナルがキューに入れられる場合、Qtは内部で引数をコピーしてイベントに格納する必要があるため、パラメータの型はQtのメタオブジェクトシステムで認識される型でなければなりません。キュー入り接続を使用しようとして、次のようなエラーメッセージが表示された場合は

QObject::connect: Cannot queue arguments of type 'MyType'
(Make sure 'MyType' is registered using qRegisterMetaType().)

というエラーメッセージが表示された場合は、引数の型をQ_DECLARE_METATYPE

オーバーロードされた関数は、qOverload の助けを借りて解決できます。

注： この関数はスレッドセーフです。

「文字列ベースの接続とファンクタベースの接続の違い」も参照してください 。

[virtual protected] void QObject::connectNotify(const QMetaMethod &signal)

この仮想関数は、このオブジェクトのsignal に何かが接続されたときに呼び出されます。

signal と特定のシグナルを比較したい場合は、次のようにQMetaMethod::fromSignal()を使用できます:

    if (signal == QMetaMethod::fromSignal(&MyObject::valueChanged)) {
        // signal is valueChanged
    }

connect() およびdisconnectNotify()も参照してください 。

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

このイベントハンドラは、カスタムイベントを受け取るためにサブクラスで再実装することができます。カスタムイベントとは、QEvent::Type 列挙型のQEvent::User 項目以上の型値を持つユーザー定義のイベントであり、通常はQEvent のサブクラスです。イベントはevent パラメータを通じて渡されます。

event() およびQEventも参照してください 。

[slot] void QObject::deleteLater()

このオブジェクトの削除をスケジュールします。

オブジェクトは、制御がイベントループに戻った時点で削除されます。この関数が呼び出された時点でイベントループが実行されていない場合（例：QCoreApplication::exec() の前に deleteLater() がオブジェクトに対して呼び出された場合）、オブジェクトはイベントループが開始された時点で削除されます。 メインのイベントループが停止した後に deleteLater() が呼び出された場合、オブジェクトは削除されません。イベントループが実行されていないスレッド内に存在するオブジェクトに対して deleteLater() が呼び出された場合、そのオブジェクトはスレッドが終了した時点で破棄されます。

QThread 内でワーカーQObject を使用する際の一般的なパターンとして、スレッドのfinished() シグナルをワーカーのdeleteLater() スロットに接続し、安全に削除されるようにすることが挙げられます：

connect(thread, &QThread::finished, worker, &QObject::deleteLater);

新しいイベントループへの進入および退出（例：モーダルダイアログの表示）では、遅延削除は実行されないことに注意してください。オブジェクトを削除するには、deleteLater() が呼び出された元のイベントループへ制御が戻る必要があります。 これは、以前のネストされたイベントループがまだ実行中の間に削除されたオブジェクトには適用されません。Qtのイベントループは、新しいネストされたイベントループが開始されるやいなや、それらのオブジェクトを削除します。

QCoreApplication::exec() やQEventLoop::exec() などを通じて Qt がイベントディスパッチャを制御していない状況では、遅延削除は自動的に処理されません。このシナリオで遅延削除を確実に行うには、以下の回避策を使用できます:

const auto *eventDispatcher = QThread::currentThread()->eventDispatcher();
QObject::connect(eventDispatcher, &QAbstractEventDispatcher::aboutToBlock,
    QThread::currentThread(), []{
        if (QThread::currentThread()->loopLevel() == 0)
            QCoreApplication::sendPostedEvents(nullptr, QEvent::DeferredDelete);
    }
);

注： この関数はスレッドセーフです。

destroyed() およびQPointerも参照してください 。

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

このシグナルは、オブジェクト `obj ` が破棄される直前に、`QPointer ` のすべてのインスタンスへの通知が完了した後に発火し、ブロックすることはできません。

このシグナルが発信されると直後に、そのオブジェクトの子オブジェクトはすべて破棄されます。

deleteLater() およびQPointerも参照してください 。

接続を切断します。

connection がinvalid であるか、すでに切断済みの場合は、何もしないでfalseを返す。

これらの関数は Qt 6.12 で導入されました。

connect()も参照してください 。

[static] bool QObject::disconnect(const QMetaObject::Connection &connection)

connection の接続を切断し、invalid にリセットします。

connection が無効であるか、すでに切断済みの場合は、何もしないで false を返します。

QT_NO_DISCONNECT_CONST_CONNECTION およびconnect()も参照してください 。

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

オブジェクト `sender ` 内の `signal ` を、オブジェクト `receiver` 内の `method ` から切断します。接続の切断に成功した場合は `true ` を返し、失敗した場合は `false` を返します。

この関数は、disconnect(const QObject *sender, const char *signal, const QObject *receiver, const char *method) と同様の機能を提供しますが、切断対象のシグナルおよびメソッドを表すためにQMetaMethod を使用します。

さらに、以下の場合は、この関数は false を返し、シグナルやスロットの切断は行われません：

1. signal sender クラスのメンバ、またはその親クラスのいずれのメンバでもない場合。
2. method が、sender クラスまたはその親クラスのいずれかのメンバーでない場合。
3. signal instance がシグナルを表していない場合。

不一致を避けるため、connect() によって返された接続ハンドルを保存し、disconnect() の呼び出しでそれを使用してください。

QMetaMethod() は、「任意のシグナル」または「受信オブジェクトの任意のスロット」という意味でワイルドカードとして使用できます。同様に、nullptr は、「任意の受信オブジェクト」という意味でreceiver に対して使用できます。この場合、メソッドも QMetaMethod() である必要があります。sender パラメータは、決してnullptr にしてはなりません。

disconnect(const QObject *sender, const char *signal, const QObject *receiver, const char *method)も参照してください。

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

オブジェクト `sender ` 内の `signal ` と、オブジェクト `receiver` 内の `method ` との接続を切断します。接続の切断に成功した場合は `true ` を返し、失敗した場合は `false` を返します。

シグナル・スロットの接続は、関連するいずれかのオブジェクトが破棄されると解除されます。

disconnect() は通常、以下の例が示すように、3つの方法で使用されます。

1. オブジェクトのシグナルに接続されているすべての接続を切断します:

       QObject::disconnect(myObject, nullptr, nullptr, nullptr);

   非静的なオーバーロード関数と同等です

       myObject->disconnect();

2. 特定のシグナルに接続されているすべてのものを切断します:

       QObject::disconnect(myObject, SIGNAL(mySignal()), nullptr, nullptr);

   非静的なオーバーロード関数と同等

       myObject->disconnect(SIGNAL(mySignal()));

3. 特定の受信機を切断する:

       QObject::disconnect(myObject, nullptr, myReceiver, nullptr);

   非静的なオーバーロード関数と同等

       myObject->disconnect(myReceiver);

不整合を避けるため、connect() によって返された接続ハンドルを保存し、disconnect() の呼び出しでそれを使用してください。

nullptr はワイルドカードとして使用でき、それぞれ「任意のシグナル」、「任意の受信オブジェクト」、または「受信オブジェクト内の任意のスロット」を意味します。

sender は、決してnullptr になってはなりません（1回の呼び出しで、複数のオブジェクトからのシグナルを切断することはできません）。

signal がnullptr の場合、receiver およびmethod をすべての信号から切断します。そうでない場合は、指定された信号のみが切断されます。

receiver がnullptr の場合、signal に接続されているすべてのものを切断します。そうでない場合、receiver 以外のオブジェクトにあるスロットは切断されません。

method がnullptr の場合、receiver に接続されているものはすべて切断されます。そうでない場合、method という名前のスロットのみが切断され、その他のスロットはそのまま残されます。receiver が省略されている場合、method はnullptr でなければならないため、すべてのオブジェクト上で特定の名前を持つスロットを切断することはできません。

注： この関数はスレッドセーフです。

関連項目: connect()。

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

このオブジェクト内のすべての信号を、receiver のmethod から切り離します。

不一致を避けるため、connect() によって返された接続ハンドルを保存し、disconnect() の呼び出しでそれを使用してください。

シグナル・スロットの接続は、関係するいずれかのオブジェクトが破棄されると解除されます。

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

receiver のmethod からsignal を切り離します。

不一致を避けるため、connect() によって返された接続ハンドルを保存し、disconnect() の呼び出しでそれを使用してください。

シグナル・スロット接続は、関連するオブジェクトのいずれかが破棄されると解除されます。

注： この関数はスレッドセーフです。

[static] template <typename PointerToMemberFunction> bool QObject::disconnect(const QObject *sender, PointerToMemberFunction signal, const QObject *receiver, PointerToMemberFunction method)

オブジェクト `sender ` 内の `signal ` と、オブジェクト `receiver` 内の `method ` との接続を切断します。接続の切断に成功した場合は `true ` を返し、失敗した場合は `false` を返します。

シグナル・スロット接続は、関連するオブジェクトのいずれかが破棄されると解除されます。

disconnect() は通常、以下の例が示すように、3つの方法で使用されます。

1. オブジェクトのシグナルに接続されているすべてのものを切断する:

       QObject::disconnect(myObject, nullptr, nullptr, nullptr);

2. 特定のシグナルに接続されているすべてのものを切断する:

       QObject::disconnect(myObject, &MyObject::mySignal, nullptr, nullptr);

3. 特定の受信者を切断する：

       QObject::disconnect(myObject, nullptr, myReceiver, nullptr);

4. 特定の信号から特定のスロットへの接続を解除します:

       QObject::disconnect(lineEdit, &QLineEdit::textChanged,
                       label,  &QLabel::setText);

nullptr はワイルドカードとして使用でき、それぞれ「任意の信号」、「任意の受信オブジェクト」、または「受信オブジェクト内の任意のスロット」を意味します。

sender は、nullptr であってはなりません。（1回の呼び出しで、複数のオブジェクトから信号の接続を解除することはできません。）

signal がnullptr である場合、receiver およびmethod をあらゆる信号から切り離します。そうでない場合は、指定された信号のみが切り離されます。

receiver がnullptr の場合、signal に接続されているすべてのものを切断します。そうでない場合は、指定されたレシーバー内のスロットのみが切断されます。receiver がnullでない状態でdisconnect()を呼び出すと、コンテキストオブジェクトとしてreceiver で接続されていたスロット関数も切断されます。

method がnullptr の場合、receiver に接続されているすべてのものを切断します。そうでない場合、method という名前のスロットのみが切断され、他のすべてのスロットはそのまま残されます。receiver が省略されている場合、method はnullptr でなければならないため、すべてのオブジェクト上の特定の名前を持つスロットを切断することはできません。

注： この関数はスレッドセーフです。

connect()も参照してください 。

[virtual protected] void QObject::disconnectNotify(const QMetaMethod &signal)

この仮想関数は、このオブジェクト内のsignal から何かが切断されたときに呼び出されます。

signal を特定のシグナルと比較する方法の例については、connectNotify()を参照してください。

このオブジェクトからすべてのシグナルが切断された場合（たとえば、disconnect() の引数 signal がnullptr であった場合など）、disconnectNotify() は 1 回だけ呼び出され、signal は無効なQMetaMethod となります（QMetaMethod::isValid() はfalse を返します）。

disconnect() およびconnectNotify()も参照してください 。

void QObject::dumpObjectInfo() const

このオブジェクトのシグナル接続などに関する情報をデバッグ出力に書き出します。

dumpObjectTree()も参照してください 。

void QObject::dumpObjectTree() const

子ノードのツリーをデバッグ出力に書き出します。

dumpObjectInfo()も参照してください 。

QList<QByteArray> QObject::dynamicPropertyNames() const

setProperty() を使用してオブジェクトに動的に追加されたすべてのプロパティの名前を返します。

[virtual] bool QObject::event(QEvent *e)

この仮想関数は、オブジェクトに対するイベントを受け取り、イベントe が認識され、処理された場合はtrueを返す必要があります。

event() 関数は、オブジェクトの挙動をカスタマイズするために再実装することができます。

処理しなかったすべてのイベントについては、必ず親イベントクラスの実装を呼び出すようにしてください。

例:

class MyClass : public QWidget
{
    Q_OBJECT

public:
    MyClass(QWidget *parent = nullptr);
    ~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()。

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

このオブジェクトが、watched オブジェクトのイベントフィルターとしてインストールされている場合、イベントをフィルタリングします。

この関数を再実装する際、event をフィルタリングして（つまり、それ以上の処理を停止させたい場合は）、trueを返してください。そうでない場合はfalseを返してください。

例：

classMainWindow :publicQMainWindow
{
public:
    MainWindow();

protected:
    booleventFilter(QObject*obj,QEvent*ev) override;

private:
    QTextEdit*textEdit;
};

MainWindow::MainWindow()
{
    textEdit= newQTextEdit;
    setCentralWidget(textEdit);

    textEdit->installEventFilter(this);
}

boolMainWindow::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{
        // イベントを親クラスに渡す
        returnQMainWindow::eventFilter(obj,event);
    }
}

上記の例では、処理されなかったイベントが基底クラスの eventFilter() 関数に渡されていることに注目してください。これは、基底クラスが独自の内部処理のために eventFilter() を再実装している可能性があるためです。

QEvent::ShortcutOverride などの一部のイベントは、伝播を防ぐために（accept() を呼び出すことで）明示的に受け入れる必要があります。

installEventFilter()も参照してください 。

template <typename T> T QObject::findChild(QAnyStringView name, Qt::FindChildOptions options = Qt::FindChildrenRecursively) const

このオブジェクトの子のうち、型 T にキャスト可能で、name という名前のものを返します。そのようなオブジェクトが存在しない場合は、nullptr を返します。name 引数が null の場合、すべてのオブジェクトが一致対象となります。空で null ではないname は、objectName が空であるオブジェクトのみと一致します。options で FindDirectChildrenOnly オプションが指定されていない限り、検索は再帰的に行われます。

検索条件に一致する子要素が複数ある場合、最も直接的な祖先が返されます。最も直接的な祖先が複数存在する場合は、children() 内の最初の子要素が返されます。その場合は、findChildren() を使用して、すべての子要素の完全なリストを取得することをお勧めします。

この例では、ボタンが親の直接の子要素でなかったとしても、parentWidget の子要素であるQPushButton である"button1" を返します:

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

この例では、parentWidget の子であるQListWidget を返します：

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

この例では、parentWidget （その直接の親）の子であるQPushButton で、"button1" という名前のオブジェクトが返されます：

QPushButton *button = parentWidget->findChild<QPushButton *>("button1", Qt::FindDirectChildrenOnly);

この例では、parentWidget （その直接の親）の子であるQListWidget を返します：

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

findChildren()も参照してください 。

[since 6.7] template <typename T> T QObject::findChild(Qt::FindChildOptions options = Qt::FindChildrenRecursively) const

このオブジェクトの子のうち、型 T にキャスト可能なものを返します。そのようなオブジェクトが存在しない場合は、nullptr を返します。options で FindDirectChildrenOnly オプションが指定されていない限り、検索は再帰的に行われます。

検索条件に一致する子オブジェクトが複数存在する場合、最も直接的な祖先が返されます。最も直接的な祖先が複数存在する場合は、children() 内の最初の子オブジェクトが返されます。その場合は、findChildren() を使用して、すべての子オブジェクトの完全なリストを取得することをお勧めします。

この関数は Qt 6.7 で導入されました。

findChildren()も参照してください 。

template <typename T> QList<T> QObject::findChildren(QAnyStringView name, Qt::FindChildOptions options = Qt::FindChildrenRecursively) const

指定されたname を持つこのオブジェクトの子オブジェクトのうち、型Tにキャスト可能なものをすべて返します。そのようなオブジェクトが存在しない場合は、空のリストを返します。name 引数がnullの場合、すべてのオブジェクトが一致対象となります。空の場合、objectName が空であるもののみが一致対象となります。options でFindDirectChildrenOnlyオプションが指定されていない限り、検索は再帰的に行われます。

次の例は、指定されたparentWidget のうち、widgetname という名前の子QWidgetのリストを検索する方法を示しています：

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

この例は、parentWidget の子であるすべてのQPushButtonを返します：

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

この例は、parentWidget の直子であるすべてのQPushButtonを返します：

QList<QPushButton *> childButtons = parentWidget.findChildren<QPushButton *>(Qt::FindDirectChildrenOnly);

findChild()も参照してください 。

[since 6.3] template <typename T> QList<T> QObject::findChildren(Qt::FindChildOptions options = Qt::FindChildrenRecursively) const

このオブジェクトの子要素のうち、型 T にキャスト可能なものをすべて返します。そのようなオブジェクトがない場合は、空のリストを返します。options で FindDirectChildrenOnly オプションが指定されていない限り、検索は再帰的に行われます。

この関数は Qt 6.3 で導入されました。

findChild()も参照してください 。

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

このオブジェクトの子要素のうち、型 T にキャスト可能であり、かつ正規表現re に一致する名前を持つものを返します。そのようなオブジェクトがない場合は、空のリストを返します。options で FindDirectChildrenOnly オプションが指定されていない限り、検索は再帰的に行われます。

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

このオブジェクトが、className を継承するクラスのインスタンス、またはclassName を継承するQObject のサブクラスのインスタンスである場合は、true を返します。それ以外の場合は、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` を返さなければなりません。

単一のオブジェクトに複数のイベントフィルターが登録されている場合、最後に登録されたフィルターが最初に有効になります。

このオブジェクトに対してfilterObj がすでにインストールされている場合、この関数はそれを移動させ、あたかも最後にインストールされたかのように動作させる。

以下は、監視対象オブジェクトのキー入力を吸収するKeyPressEater クラスです：

classKeyPressEater :publicQObject
{
    Q_OBJECT
public:
    KeyPressEater(QObject*parent =nullptr) : QObject(parent) {}
//...

protected:
    booleventFilter(QObject*obj,QEvent*event) override;
};

boolKeyPressEater::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{
        // 標準的なイベント処理
        returnQObject::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);

たとえば、QShortcut クラスは、この手法を使ってショートカットキーの押下をインターセプトしています。

なお、フィルタリング対象のオブジェクトは、このオブジェクトと同じスレッドにある必要があります。filterObj が別のスレッドにある場合、この関数は何も行いません。この関数の呼び出し後に、filterObj またはこのオブジェクトのいずれかが別のスレッドに移動された場合、両方のオブジェクトが再び同じスレッドに属するようになるまで（アフィニティが解除されない限り）、イベントフィルタは呼び出されません。

removeEventFilter()、eventFilter()、およびevent()も参照してください 。

[noexcept, since 6.11] bool QObject::isQmlExposed() const

そのオブジェクトがQMLエンジンによって作成されたものか、それともQJSEngine::setObjectOwnership() を通じて明示的に所有権が設定されたものかを返します。

この関数は Qt 6.11 で導入されました。

[since 6.4] bool QObject::isQuickItemType() const

オブジェクトがQQuickItem である場合はtrue を返し、それ以外の場合はfalse を返します。

この関数の呼び出しは、inherits("QQuickItem") を呼び出すのと同じですが、処理速度がはるかに高速です。

この関数は Qt 6.4 で導入されました。

[protected] bool QObject::isSignalConnected(const QMetaMethod &signal) const

signal が少なくとも1つのレシーバーに接続されている場合はtrue を返し、そうでない場合はfalse を返します。

signal このオブジェクトのシグナルメンバーでなければなりません。そうでない場合、動作は未定義となります。

    static const QMetaMethod valueChangedSignal = QMetaMethod::fromSignal(&MyObject::valueChanged);
    if (QObject::isSignalConnected(valueChangedSignal)) {
        QByteArray data;
        data = get_the_value();       // expensive operation
        emit valueChanged(data);
    }

上記のコードスニペットが示すように、この関数を使用することで、負荷の高い操作を回避したり、誰もリッスンしていないシグナルを発行したりすることを防ぐことができます。

receivers()も参照してください 。

bool QObject::isWidgetType() const

オブジェクトがウィジェットである場合は `true ` を返し、そうでない場合は `false` を返します。

この関数の呼び出しは、inherits("QWidget") の呼び出しと同等ですが、はるかに高速です。

bool QObject::isWindowType() const

オブジェクトがウィンドウである場合は `true ` を返し、そうでない場合は `false` を返します。

この関数を呼び出すことは、inherits("QWindow") を呼び出すことと同じですが、処理速度がはるかに速いという点が異なります。

void QObject::killTimer(int id)

指定されたタイマー識別子を持つタイマーを停止します（id ）。

このタイマー識別子は、タイマーイベントが開始された際にstartTimer() によって返されます。

timerEvent() およびstartTimer()も参照してください 。

[since 6.8] void QObject::killTimer(Qt::TimerId id)

この関数はQt 6.8で導入されました。

[virtual] const QMetaObject *QObject::metaObject() const

このオブジェクトのメタオブジェクトへのポインタを返します。

メタオブジェクトには、QObject を継承するクラスに関する情報（クラス名、スーパークラス名、プロパティ、シグナル、スロットなど）が含まれます。Q_OBJECT マクロを含むすべてのQObject サブクラスには、メタオブジェクトが存在します。

メタオブジェクト情報は、シグナル／スロットの接続メカニズムやプロパティシステムによって必要とされます。また、inherits() 関数もメタオブジェクトを利用します。

実際のオブジェクトインスタンスへのポインタがない場合でも、クラスのメタオブジェクトにアクセスしたい場合は、staticMetaObject を使用できます。

例：

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

QPushButton::staticMetaObject.className();  // returns "QPushButton"

staticMetaObjectも参照してください 。

bool QObject::moveToThread(QThread *targetThread)

このオブジェクトとその子オブジェクトのスレッドアフィニティを変更し、成功した場合はtrue を返します。親オブジェクトがある場合、このオブジェクトを移動することはできません。イベント処理はtargetThread で継続されます。

オブジェクトをメインスレッドに移動するには、QApplication::instance() を使用して現在のアプリケーションへのポインタを取得し、QApplication::thread() を使用してそのアプリケーションが実行されているスレッドを取得します。例：

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

targetThread の結果がnullptr の場合、このオブジェクトおよびその子オブジェクトはもはやどのスレッドにも関連付けられていないため、これらに関するすべてのイベント処理が停止します。

なお、そのオブジェクトのすべてのアクティブなタイマーはリセットされることに注意してください。タイマーはまず現在のスレッドで停止され、targetThread で（同じ間隔で）再起動されます。その結果、オブジェクトをスレッド間で絶えず移動させると、タイマーイベントが無期限に延期される可能性があります。

スレッドアフィニティが変更される直前に、このオブジェクトに対してQEvent::ThreadChange イベントが送信されます。このイベントを処理して、特別な処理を実行することができます。なお、このオブジェクトに投稿された新しいイベントは、targetThread で処理されます（ただし、nullptr でない場合に限ります）。nullptr の場合、このオブジェクトやその子オブジェクトはもはやどのスレッドにも関連付けられていないため、イベント処理は一切行われません。

Qt 6.7 以前のバージョンでは、この関数には戻り値がありませんでした (void)。

thread()も参照してください 。

[private signal] void QObject::objectNameChanged(const QString &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 を返します。このポインタは、このオブジェクトのスレッドコンテキストからこの関数を呼び出すスロットの実行中にのみ有効です。

送信者が破棄された場合、またはスロットが送信者のシグナルから切断された場合、この関数が返すポインタは無効になります。

関連項目: ` senderSignalIndex()`。

[protected] int QObject::senderSignalIndex() const

現在実行中のスロットを呼び出したシグナルのメタメソッドインデックスを返します。このインデックスは、sender() によって返されるクラスのメンバです。シグナルによってアクティブ化されたスロットの外部から呼び出された場合は、-1 が返されます。

デフォルトパラメータを持つシグナルの場合、この関数は、connect() でどのパラメータが使用されたかに関係なく、常にすべてのパラメータを含むインデックスを返します。たとえば、シグナル `destroyed(QObject *obj = \nullptr) ` には（パラメータがある場合とない場合で）2つの異なるインデックスがありますが、この関数は常にパラメータを含むインデックスを返します。ただし、異なるパラメータでシグナルをオーバーロードした場合は、この挙動は適用されません。

関連項目： sender()、QMetaObject::indexOfSignal()、QMetaObject::method()も参照してください 。

void QObject::setObjectName(const QString &name)

オブジェクトの名前を「name 」に設定します。

関連項目: objectName()。

[since 6.4] void QObject::setObjectName(QAnyStringView name)

この関数は Qt 6.4 で導入されました。

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

[since 6.6] bool QObject::setProperty(const char *name, QVariant &&value)

この関数は Qt 6.6 で導入されました。

[noexcept] bool QObject::signalsBlocked() const

シグナルがブロックされている場合は `true ` を返し、そうでない場合は `false` を返します。

デフォルトでは、シグナルはブロックされません。

blockSignals() およびQSignalBlockerも参照してください 。

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

これは、timerType 型のタイマーをinterval ミリ秒のタイムアウトで開始するオーバーロード関数です。これは、以下の呼び出しと同等です。

startTimer(std::chrono::milliseconds{interval}, timerType);

Qt 6.10 以降、負のインターバルを設定すると、実行時の警告が表示され、その値は 1ms にリセットされます。 Qt 6.10 以前では、Qt Timer では負の間隔を設定することは可能でしたが、予期せぬ動作（例えば、タイマーが実行中であれば停止したり、まったく開始しなかったりすることなど）が発生していました。

timerEvent()、killTimer()、QChronoTimer 、およびQBasicTimerも参照してください 。

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

タイマーを開始し、タイマー識別子を返します。タイマーを開始できなかった場合は、0を返します。

killTimer()が呼び出されるまで、interval ごとにタイマーイベントが発生します。interval がstd::chrono::duration::zero() に等しい場合、タイマーイベントは、制御がイベントループに戻るたびに1回発生します。つまり、処理すべきネイティブウィンドウシステムイベントがもうない状態です。

Qt 6.10 以降、負のインターバルを設定すると、実行時の警告が表示され、値は 1ms にリセットされます。 Qt 6.10 以前では、Qt Timer で負のインターバルを設定することは可能でしたが、予期せぬ動作（例えば、タイマーが実行中であれば停止したり、まったく開始されなかったりすること）が発生していました。

タイマーイベントが発生すると、仮想関数 `timerEvent()` が、イベントパラメータクラス `QTimerEvent ` とともに呼び出されます。タイマーイベントを取得するには、この関数を再実装してください。

複数のタイマーが実行中の場合、QTimerEvent::id() メソッドを使用することで、どのタイマーが起動したかを確認できます。

例：

classMyObject :publicQObject
{
    Q_OBJECT

public:
    MyObject(QObject*parent =nullptr);

Q_SIGNALS:
    voidvalueChanged();

protected:
    voidtimerEvent(QTimerEvent*event) override;
};

MyObject::MyObject(QObject*parent)
    : QObject(parent)
{
    using namespacestd::chrono_literals;

    startTimer(50ms);
    startTimer(5s);
    startTimer(10min);
    startTimer(1h);
}

voidMyObject::timerEvent(QTimerEvent*event)
{
    qDebug() << "Timer ID:" << event->id();
}

なお、タイマーの精度は、基盤となるオペレーティングシステムやハードウェアによって異なります。

timerType 引数を使用すると、タイマーの精度をカスタマイズできます。さまざまなタイマータイプに関する情報については、Qt::TimerType を参照してください。ほとんどのプラットフォームでは 20 ミリ秒の精度がサポートされていますが、それ以上の精度を提供するプラットフォームもあります。Qt が要求された数のタイマーイベントを配信できない場合、一部のイベントは黙って破棄されます。

QTimer およびQChronoTimer クラスは、イベントの代わりにシングルショットタイマーとタイマーシグナルを用いた高レベルなプログラミングインターフェースを提供します。また、QBasicTimer クラスもあり、これはQChronoTimer よりも軽量ですが、タイマーIDを直接使用するよりも扱いやすくなっています。

    QObject *obj;
    //...
    const auto id = Qt::TimerId {obj->startTimer(100ms)};
    if (id != Qt::TimerId::Invalid)
    {
        // The timer has been started successfully
    }

timerEvent()、killTimer()、QChronoTimer 、およびQBasicTimerも参照してください 。

QThread *QObject::thread() const

そのオブジェクトが存在するスレッドを返します。

moveToThread()も参照してください 。

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

このイベントハンドラは、サブクラスで再実装することで、そのオブジェクトのタイマーイベントを受け取ることができます。

QChronoTimer は、タイマー機能に対するより高レベルのインターフェースを提供するとともに、タイマーに関するより一般的な情報も提供します。タイマーイベントは、event パラメータを通じて渡されます。

startTimer()、killTimer()、およびevent()も参照してください 。

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

sourceText の翻訳版を返します。複数形を含む文字列については、オプションでdisambiguation の文字列とn の値を基に翻訳を行います。適切な翻訳文字列が存在しない場合は、QString::fromUtf8 （sourceText ）を返します。

例：

void SpreadSheet::setupMenuBar()
{
    QMenu *fileMenu = menuBar()->addMenu(tr("&File"));
    ...

同じコンテキスト内で異なるロールにおいて同じsourceText が使用される場合、disambiguation に追加の識別文字列を渡すことができます（デフォルトはnullptr ）。

例：

MyWindow::MyWindow()
{
    QLabel *senderLabel = new QLabel(tr("Name:"));
    QLabel *recipientLabel = new QLabel(tr("Name:", "recipient"));
    ...

Qtの翻訳メカニズム全般に関する詳細な説明については「翻訳用のソースコードの記述」を、曖昧性の解消に関する情報については「同一テキストの曖昧性解消」のセクションを参照してください。

関連項目： QCoreApplication::translate() およびQt による国際化。