QObject Class

Dokumentation zu den Mitgliedsfunktionen

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

Erstellt ein Objekt mit dem übergeordneten Objekt „ parent “.

Das übergeordnete Objekt eines Objekts kann als dessen Eigentümer betrachtet werden. Beispielsweise ist ein „ dialog box “ das übergeordnete Objekt der darin enthaltenen Schaltflächen „ OK “ und „ Cancel “.

Der Destruktor eines übergeordneten Objekts löscht alle untergeordneten Objekte.

Wird parent auf nullptr gesetzt, wird ein Objekt ohne übergeordnetes Objekt erstellt. Handelt es sich bei dem Objekt um ein Widget, wird es zu einem Fenster der obersten Ebene.

Siehe auch parent(), findChild() und findChildren().

[virtual noexcept] QObject::~QObject()

Löscht das Objekt und entfernt dabei alle seine untergeordneten Objekte.

Alle Signale zum und vom Objekt werden automatisch getrennt, und alle ausstehenden, für das Objekt gesendeten Ereignisse werden aus der Ereigniswarteschlange entfernt. Es ist jedoch oft sicherer, ` deleteLater()` zu verwenden, anstatt eine Unterklasse von ` QObject ` direkt zu löschen.

Siehe auch deleteLater().

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

Ist „ block “ wahr, werden die von diesem Objekt ausgesendeten Signale blockiert (d. h., das Aussenden eines Signals löst keine damit verbundenen Aktionen aus). Ist „ block “ falsch, findet keine solche Blockierung statt.

Der Rückgabewert ist der vorherige Wert von ` signalsBlocked()`.

Beachten Sie, dass das Signal „ destroyed()“ auch dann ausgesendet wird, wenn die Signale dieses Objekts blockiert wurden.

Signale, die während der Blockierung ausgesendet werden, werden nicht gepuffert.

Siehe auch signalsBlocked() und QSignalBlocker.

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

Dieser Ereignis-Handler kann in einer Unterklasse neu implementiert werden, um Ereignisse von untergeordneten Elementen zu empfangen. Das Ereignis wird über den Parameter „ event “ übergeben.

QEvent::ChildAdded Die Ereignisse „ QEvent::ChildRemoved “ und „ “ werden an Objekte gesendet, wenn untergeordnete Elemente hinzugefügt oder entfernt werden. In beiden Fällen können Sie sich nur darauf verlassen, dass das untergeordnete Element ein „ QObject “ ist oder – falls „ isWidgetType()“ den Wert „ true “ zurückgibt – ein „ QWidget “. (Dies liegt daran, dass im Fall von „ ChildAdded “ das untergeordnete Element noch nicht vollständig konstruiert ist und im Fall von „ ChildRemoved “ möglicherweise bereits zerstört wurde.)

QEvent::ChildPolished Ereignisse werden an Widgets gesendet, wenn untergeordnete Elemente „polished“ sind oder wenn „polished“ untergeordnete Elemente hinzugefügt werden. Wenn Sie ein „child polished“-Ereignis erhalten, ist die Erstellung des untergeordneten Elements in der Regel abgeschlossen. Dies ist jedoch nicht garantiert, und während der Ausführung des Konstruktors eines Widgets können mehrere „polished“-Ereignisse übermittelt werden.

Für jedes untergeordnete Widget erhalten Sie ein „ ChildAdded “-Ereignis, null oder mehrere „ ChildPolished “-Ereignisse und ein „ ChildRemoved “-Ereignis.

Das Ereignis „ ChildPolished “ wird ausgelassen, wenn ein untergeordnetes Widget unmittelbar nach dem Hinzufügen wieder entfernt wird. Wird ein untergeordnetes Widget während des Aufbaus und der Zerstörung mehrmals poliert, können Sie mehrere „child polished“-Ereignisse für dasselbe untergeordnete Widget erhalten, jedes Mal mit einer anderen virtuellen Tabelle.

Siehe auch „ event()“.

const QObjectList &QObject::children() const

Gibt eine Liste von untergeordneten Objekten zurück. Die Klasse „ QObjectList “ ist in der Header-Datei „ <QObject> “ wie folgt definiert:

typedef QList<QObject*> QObjectList;

Das zuerst hinzugefügte untergeordnete Objekt ist das „ first “-Objekt in der Liste, und das zuletzt hinzugefügte untergeordnete Objekt ist das „ last “-Objekt in der Liste, d. h., neue untergeordnete Objekte werden am Ende angehängt.

Beachten Sie, dass sich die Reihenfolge in der Liste ändert, wenn die „ QWidget “-Unterelemente „ raised “ oder „ lowered “ sind. Ein Widget, das angehoben wird, wird zum letzten Objekt in der Liste, und ein Widget, das abgesenkt wird, wird zum ersten Objekt in der Liste.

Siehe auch findChild(), findChildren(), parent() und setParent().

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

Erstellt eine Verbindung des angegebenen „ type “ vom „ signal “ im „ sender “-Objekt zum „ method “ im „ receiver “-Objekt. Gibt ein Handle für die Verbindung zurück, mit dem diese später getrennt werden kann.

Das Verbindungs-Handle ist ungültig, wenn die Verbindung nicht hergestellt werden kann, beispielsweise weil die Parameter ungültig waren. Sie können überprüfen, ob „ QMetaObject::Connection “ gültig ist, indem Sie den Wert in einen bool-Wert umwandeln.

Diese Funktion arbeitet genauso wie ` connect(const QObject *sender, const char *signal, const QObject *receiver, const char *method, Qt::ConnectionType type) `, verwendet jedoch ` QMetaMethod `, um Signal und Methode anzugeben.

Siehe auch ` 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)

Stellt eine Verbindung zwischen dem angegebenen „ type “ aus dem „ signal “ im „ sender “-Objekt und dem „ method “ im „ receiver “-Objekt her. Gibt ein Handle für die Verbindung zurück, mit dem diese später getrennt werden kann.

Bei der Angabe von „ signal “ und „ method “ müssen Sie die Makros „ SIGNAL() “ und „ SLOT() “ verwenden, zum Beispiel:

QLabel *label = new QLabel;
QScrollBar *scrollBar = new QScrollBar;
QObject::connect(scrollBar, SIGNAL(valueChanged(int)),
                 label,  SLOT(setNum(int)));

Dieses Beispiel stellt sicher, dass das Label stets den aktuellen Wert der Bildlaufleiste anzeigt. Beachten Sie, dass die Parameter für Signale und Slots keine Variablennamen enthalten dürfen, sondern nur den Typ. Folgendes würde beispielsweise nicht funktionieren und „false“ zurückgeben:

// WRONG
QObject::connect(scrollBar, SIGNAL(valueChanged(int value)),
                 label, SLOT(setNum(int value)));

Ein Signal kann auch mit einem anderen Signal verbunden werden:

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

In diesem Beispiel leitet der Konstruktor „ MyWidget “ ein Signal von einer privaten Member-Variablen weiter und stellt es unter einem Namen bereit, der sich auf „ MyWidget “ bezieht.

Ein Signal kann mit vielen Slots und Signalen verbunden werden. Ein Slot kann mit vielen Signalen verbunden werden.

Wenn ein Signal mit mehreren Slots verbunden ist, werden die Slots bei der Aussendung des Signals in derselben Reihenfolge aktiviert, in der die Verbindungen hergestellt wurden.

Die Funktion gibt ein ` QMetaObject::Connection ` zurück, das ein Handle für eine Verbindung darstellt, sofern das Signal erfolgreich mit dem Slot verbunden wurde. Das Verbindungs-Handle ist ungültig, wenn die Verbindung nicht hergestellt werden kann, beispielsweise wenn ` QObject ` die Existenz von ` signal ` oder ` method` nicht überprüfen kann oder wenn deren Signaturen nicht kompatibel sind. Du kannst überprüfen, ob das Handle gültig ist, indem du es in einen `bool` umwandelst.

Standardmäßig wird für jede von Ihnen hergestellte Verbindung ein Signal ausgegeben; bei doppelten Verbindungen werden zwei Signale ausgegeben. Sie können alle diese Verbindungen mit einem einzigen Aufruf von ` disconnect()` trennen. Wenn Sie den Parameter ` Qt::UniqueConnection ` type übergeben, wird die Verbindung nur hergestellt, wenn es sich nicht um ein Duplikat handelt. Wenn bereits ein Duplikat vorhanden ist (genau dasselbe Signal an genau denselben Slot bei denselben Objekten), schlägt die Verbindung fehl und `connect` gibt ein ungültiges ` QMetaObject::Connection` zurück.

Der optionale Parameter „ type “ beschreibt die Art der herzustellenden Verbindung. Insbesondere legt er fest, ob ein bestimmtes Signal sofort an einen Slot übermittelt oder zur späteren Übermittlung in die Warteschlange gestellt wird. Wird das Signal in die Warteschlange gestellt, müssen die Parameter von Typen sein, die dem Metobjektsystem von Qt bekannt sind, da Qt die Argumente kopieren muss, um sie im Hintergrund in einem Ereignis zu speichern. Wenn Sie versuchen, eine Verbindung mit Warteschlange zu verwenden, und die Fehlermeldung

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

, rufen Sie ` qRegisterMetaType()` auf, um den Datentyp zu registrieren, bevor Sie die Verbindung herstellen.

Hinweis: Diese Funktion ist threadsicher.

Siehe auch disconnect(), sender(), qRegisterMetaType(), Q_DECLARE_METATYPE() sowie Unterschiede zwischen stringbasierten und funktorbasierten Verbindungen.

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

Erstellt eine Verbindung von signal im Objekt sender zu functor und gibt ein Handle für die Verbindung zurück

Das Signal muss eine Funktion sein, die im Header als Signal deklariert ist. Die Slot-Funktion kann eine beliebige Funktion oder ein beliebiger Funktor sein, der mit dem Signal verbunden werden kann. Eine Slot-Funktion kann mit einem bestimmten Signal verbunden werden, wenn das Signal mindestens so viele Argumente hat wie die Slot-Funktion. Es muss eine implizite Konvertierung zwischen den Typen der entsprechenden Argumente im Signal und im Slot vorhanden sein.

Beispiel:

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

Es können auch Lambda-Ausdrücke verwendet werden:

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

Die Verbindung wird automatisch getrennt, wenn der Sender zerstört wird. Sie sollten jedoch darauf achten, dass alle innerhalb des Funktors verwendeten Objekte noch vorhanden sind, wenn das Signal ausgelöst wird.

Aus diesem Grund wird empfohlen, die Überladung von `connect()` zu verwenden, die zusätzlich einen ` QObject ` als Empfänger/Kontext akzeptiert. Die Verwendung der kontextlosen Überladung lässt sich durch die Definition des Makros ` QT_NO_CONTEXTLESS_CONNECT ` deaktivieren.

Überladene Funktionen können mithilfe von ` qOverload` aufgelöst werden.

Hinweis: Diese Funktion ist threadsicher.

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

Stellt eine Verbindung zwischen „ signal “ des Objekts „ sender “ und „ method “ dieses Objekts her.

Entspricht connect(sender, signal, this, method, type).

Jede von Ihnen hergestellte Verbindung sendet ein Signal aus, sodass doppelte Verbindungen zwei Signale ausgeben. Sie können eine Verbindung mit ` disconnect()` trennen.

Hinweis: Diese Funktion ist threadsicher.

Siehe auch 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)

Erstellt eine Verbindung zwischen einem angegebenen ` type ` aus ` signal ` im Objekt ` sender ` und ` functor `, die in eine bestimmte Ereignisschleife von ` context` eingefügt werden soll, und gibt ein Handle für die Verbindung zurück.

Das Signal muss eine Funktion sein, die im Header als Signal deklariert wurde. Die Slot-Funktion kann eine beliebige Funktion oder ein beliebiger Funktor sein, der mit dem Signal verbunden werden kann. Eine Slot-Funktion kann mit einem bestimmten Signal verbunden werden, wenn das Signal mindestens so viele Argumente hat wie die Slot-Funktion. Es muss eine implizite Konvertierung zwischen den Typen der entsprechenden Argumente im Signal und im Slot geben.

Beispiel:

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

Lambda-Ausdrücke können ebenfalls verwendet werden:

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

Die Verbindung wird automatisch getrennt, wenn der Absender oder der Kontext zerstört wird. Sie sollten jedoch darauf achten, dass alle innerhalb des Funktors verwendeten Objekte noch vorhanden sind, wenn das Signal ausgelöst wird.

Überladene Funktionen können mithilfe von ` qOverload` aufgelöst werden.

Hinweis: Diese Funktion ist threadsicher.

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

Erstellt eine Verbindung des angegebenen „ type “ vom „ signal “ im „ sender “-Objekt zum „ method “ im „ receiver “-Objekt. Gibt ein Handle für die Verbindung zurück, mit dem diese später getrennt werden kann.

Das Signal muss eine Funktion sein, die im Header als Signal deklariert ist. Die Slot-Funktion kann jede Member-Funktion sein, die mit dem Signal verbunden werden kann. Ein Slot kann mit einem bestimmten Signal verbunden werden, wenn das Signal mindestens so viele Argumente hat wie der Slot und eine implizite Konvertierung zwischen den Typen der entsprechenden Argumente im Signal und im Slot besteht.

Beispiel:

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

Dieses Beispiel stellt sicher, dass das Label immer den aktuellen Text des Zeilenbearbeitungsfelds anzeigt.

Ein Signal kann mit vielen Slots und Signalen verbunden werden. Ein Slot kann mit vielen Signalen verbunden werden.

Wenn ein Signal mit mehreren Slots verbunden ist, werden die Slots in derselben Reihenfolge aktiviert, in der die Verbindung hergestellt wurde, sobald das Signal ausgesendet wird

Die Funktion gibt ein Handle für eine Verbindung zurück, wenn sie das Signal erfolgreich mit dem Slot verbindet. Das Verbindungs-Handle ist ungültig, wenn die Verbindung nicht hergestellt werden kann, beispielsweise wenn ` QObject ` die Existenz von ` signal ` nicht überprüfen kann (falls dieses nicht als Signal deklariert wurde). Sie können überprüfen, ob das ` QMetaObject::Connection ` gültig ist, indem Sie es in einen `bool` umwandeln.

Standardmäßig wird für jede von Ihnen hergestellte Verbindung ein Signal ausgegeben; bei doppelten Verbindungen werden zwei Signale ausgegeben. Sie können alle diese Verbindungen mit einem einzigen Aufruf von ` disconnect()` trennen. Wenn Sie den Parameter ` Qt::UniqueConnection ` ` type` übergeben, wird die Verbindung nur hergestellt, wenn es sich nicht um ein Duplikat handelt. Wenn bereits ein Duplikat vorhanden ist (genau dasselbe Signal an genau denselben Slot bei denselben Objekten), schlägt die Verbindung fehl und `connect` gibt ein ungültiges ` QMetaObject::Connection` zurück.

Der optionale Parameter „ type “ beschreibt die Art der herzustellenden Verbindung. Insbesondere bestimmt er, ob ein bestimmtes Signal sofort an einen Slot übermittelt oder zur späteren Übermittlung in die Warteschlange gestellt wird. Wird das Signal in die Warteschlange gestellt, müssen die Parameter Typen aufweisen, die dem Metaobjektsystem von Qt bekannt sind, da Qt die Argumente kopieren muss, um sie im Hintergrund in einem Ereignis zu speichern. Wenn Sie versuchen, eine Verbindung mit Warteschlange zu verwenden, und die Fehlermeldung

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

stellen Sie sicher, dass Sie den Argumenttyp mit Q_DECLARE_METATYPE

Überladene Funktionen können mithilfe von qOverload aufgelöst werden.

Hinweis: Diese Funktion ist threadsicher.

Siehe auch Unterschiede zwischen stringbasierten und funktorbasierten Verbindungen.

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

Diese virtuelle Funktion wird aufgerufen, wenn etwas an „ signal “ in diesem Objekt angeschlossen wurde.

Wenn Sie „ signal “ mit einem bestimmten Signal vergleichen möchten, können Sie „ QMetaMethod::fromSignal()“ wie folgt verwenden:

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

Siehe auch „ connect()“ und „ disconnectNotify()“.

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

Dieser Ereignishandler kann in einer Unterklasse neu implementiert werden, um benutzerdefinierte Ereignisse zu empfangen. Benutzerdefinierte Ereignisse sind Ereignisse, deren Typwert mindestens so groß ist wie der Wert „ QEvent::User “ der Enumeration „ QEvent::Type “ und die in der Regel eine Unterklasse von „ QEvent “ sind. Das Ereignis wird über den Parameter „ event “ übergeben.

Siehe auch „ event()“ und „ QEvent “.

[slot] void QObject::deleteLater()

Markiert dieses Objekt zur Löschung vor.

Das Objekt wird gelöscht, sobald die Kontrolle an die Ereignisschleife zurückgegeben wird. Wenn die Ereignisschleife zum Zeitpunkt des Aufrufs dieser Funktion nicht läuft (z. B. wenn `deleteLater()` für ein Objekt vor ` QCoreApplication::exec()` aufgerufen wird), wird das Objekt gelöscht, sobald die Ereignisschleife gestartet wird. Wird `deleteLater()` aufgerufen, nachdem die Hauptereignisschleife beendet wurde, wird das Objekt nicht gelöscht. Wird `deleteLater()` für ein Objekt aufgerufen, das sich in einem Thread befindet, in dem keine Ereignisschleife läuft, wird das Objekt zerstört, sobald der Thread beendet wird.

Ein gängiges Muster bei der Verwendung eines Worker- QObject s in einem „ QThread “ besteht darin, das Signal „ finished() “ des Threads mit dem Slot „ deleteLater() “ des Workers zu verbinden, um sicherzustellen, dass dieser sicher gelöscht wird:

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

Beachten Sie, dass beim Ein- und Aussteigen aus einer neuen Ereignisschleife (z. B. durch das Öffnen eines modalen Dialogs) die verzögerte Löschung nicht ausgeführt wird; damit das Objekt gelöscht wird, muss die Steuerung zu der Ereignisschleife zurückkehren, aus der `deleteLater()` aufgerufen wurde. Dies gilt nicht für Objekte, die gelöscht wurden, während eine vorherige, verschachtelte Ereignisschleife noch lief: Die Qt-Ereignisschleife löscht diese Objekte, sobald die neue verschachtelte Ereignisschleife startet.

In Situationen, in denen Qt den Ereignisdispatcher nicht über z. B. ` QCoreApplication::exec()` oder ` QEventLoop::exec()` steuert, werden aufgeschobene Löschvorgänge nicht automatisch verarbeitet. Um in diesem Szenario eine aufgeschobene Löschung sicherzustellen, kann die folgende Problemumgehung verwendet werden:

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

Hinweis: Diese Funktion ist threadsicher.

Siehe auch ` destroyed()` und ` QPointer`.

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

Dieses Signal wird unmittelbar vor der Zerstörung des Objekts „ obj “ ausgesendet, nachdem alle Instanzen von „ QPointer “ benachrichtigt wurden, und kann nicht blockiert werden.

Alle untergeordneten Objekte des Objekts werden unmittelbar nach der Auslösung dieses Signals zerstört.

Siehe auch deleteLater() und QPointer.

Eine Verbindung trennen.

Wenn „ connection “ den Wert „ invalid “ hat oder die Verbindung bereits getrennt wurde, wird nichts unternommen und „false“ zurückgegeben.

Diese Funktionen wurden in Qt 6.12 eingeführt.

Siehe auch ` connect()`.

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

Trennt die Verbindung zu connection und setzt sie auf invalid zurück.

Wenn connection ungültig ist oder bereits getrennt wurde, wird nichts unternommen und false zurückgegeben.

Siehe auch QT_NO_DISCONNECT_CONST_CONNECTION und connect().

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

Trennt die Verbindung „ signal “ im Objekt „ sender “ von „ method “ im Objekt „ receiver “. Gibt „ true “ zurück, wenn die Verbindung erfolgreich getrennt wurde; andernfalls wird „ false “ zurückgegeben.

Diese Funktion bietet dieselben Möglichkeiten wie disconnect(const QObject *sender, const char *signal, const QObject *receiver, const char *method), verwendet jedoch QMetaMethod zur Darstellung des Signals und der Methode, die getrennt werden soll.

Zudem gibt diese Funktion „false“ zurück und trennt keine Signale und Slots, wenn:

1. signal kein Mitglied der Sender-Klasse oder einer ihrer übergeordneten Klassen ist.
2. method kein Mitglied der Empfängerklasse oder einer ihrer übergeordneten Klassen ist.
3. signal „instance“ kein Signal darstellt.

Um Inkonsistenzen zu vermeiden, speichern Sie das von ` connect()` zurückgegebene Verbindungs-Handle und verwenden Sie es beim Aufruf von ` disconnect()`.

`QMetaMethod()` kann als Platzhalter im Sinne von „beliebiges Signal“ oder „beliebiger Slot im empfangenden Objekt“ verwendet werden. Ebenso kann ` nullptr ` für ` receiver ` im Sinne von „beliebiges empfangendes Objekt“ verwendet werden. In diesem Fall sollte die Methode ebenfalls `QMetaMethod()` sein. Der Parameter ` sender ` darf niemals ` nullptr` sein.

Siehe auch ` 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)

Trennt die Verbindung „ signal “ im Objekt „ sender “ von „ method “ im Objekt „ receiver “. Gibt „ true “ zurück, wenn die Verbindung erfolgreich getrennt wurde; andernfalls wird „ false “ zurückgegeben.

Eine Signal-Slot-Verbindung wird entfernt, wenn eines der beteiligten Objekte zerstört wird.

disconnect() wird typischerweise auf drei Arten verwendet, wie die folgenden Beispiele zeigen.

1. Alle mit den Signalen eines Objekts verbundenen Verbindungen trennen:

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

   entspricht der nicht-statischen überladenen Funktion

       myObject->disconnect();

2. Trenne alles, was mit einem bestimmten Signal verbunden ist:

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

   entspricht der nicht-statischen überladenen Funktion

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

3. Trenne einen bestimmten Empfänger:

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

   entspricht der nicht-statischen überladenen Funktion

       myObject->disconnect(myReceiver);

Um Inkonsistenzen zu vermeiden, speichern Sie das von ` connect()` zurückgegebene Verbindungs-Handle und verwenden Sie es beim Aufruf von ` disconnect()`.

nullptr kann als Platzhalter verwendet werden, der jeweils „beliebiges Signal“, „beliebiges Empfängerobjekt“ oder „beliebiger Slot im Empfängerobjekt“ bedeutet.

sender darf niemals nullptr sein. (Sie können in einem einzigen Aufruf nicht die Signale von mehr als einem Objekt trennen.)

Ist signal nullptr , trennt es receiver und method von allen Signalen. Andernfalls wird nur das angegebene Signal getrennt.

Ist receiver gleich nullptr, werden alle mit signal verbundenen Elemente getrennt. Andernfalls werden Slots in anderen Objekten als receiver nicht getrennt.

Ist „ method “ gleich „ nullptr “, werden alle Verbindungen getrennt, die mit „ receiver “ verbunden sind. Andernfalls werden nur Slots mit dem Namen „ method “ getrennt, während alle anderen Slots unverändert bleiben. „ method “ muss gleich „ nullptr “ sein, wenn „ receiver “ weggelassen wird; daher ist es nicht möglich, einen konkret benannten Slot bei allen Objekten zu trennen.

Hinweis: Diese Funktion ist threadsicher.

Siehe auch ` connect()`.

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

Trennt alle Signale in diesem Objekt von „ method “ unter receiver ab.

Um Inkonsistenzen zu vermeiden, speichern Sie das von ` connect()` zurückgegebene Verbindungs-Handle und verwenden Sie es beim Aufruf von ` disconnect()`.

Eine Signal-Slot-Verbindung wird entfernt, wenn eines der beteiligten Objekte zerstört wird.

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

Trennt die Verbindung zwischen signal und method von receiver.

Um Inkonsistenzen zu vermeiden, speichern Sie das von connect() zurückgegebene Verbindungs-Handle und verwenden Sie es beim Aufruf von disconnect().

Eine Signal-Slot-Verbindung wird entfernt, wenn eines der beteiligten Objekte zerstört wird.

Hinweis: Diese Funktion ist threadsicher.

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

Trennt die Verbindung „ signal “ im Objekt „ sender “ von „ method “ im Objekt „ receiver “. Gibt „ true “ zurück, wenn die Verbindung erfolgreich getrennt wurde; andernfalls wird „ false “ zurückgegeben.

Eine Signal-Slot-Verbindung wird entfernt, wenn eines der beteiligten Objekte zerstört wird.

disconnect() wird typischerweise auf drei Arten verwendet, wie die folgenden Beispiele zeigen.

1. Alle Verbindungen zu den Signalen eines Objekts trennen:

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

2. Alle Verbindungen zu einem bestimmten Signal trennen:

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

3. Einen bestimmten Empfänger trennen:

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

4. Eine Verbindung von einem bestimmten Signal zu einem bestimmten Steckplatz trennen:

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

nullptr kann als Platzhalter verwendet werden und bedeutet jeweils „beliebiges Signal“, „beliebiges Empfangsobjekt“ oder „beliebiger Steckplatz im Empfangsobjekt“.

Die „ sender “ darf niemals „ nullptr “ lauten. (Sie können in einem einzigen Aufruf nicht die Verbindung von Signalen zu mehr als einem Objekt trennen.)

Ist ` signal ` ` nullptr`, werden ` receiver ` und ` method ` von allen Signalen getrennt. Andernfalls wird nur das angegebene Signal getrennt.

Ist ` receiver ` gleich ` nullptr`, werden alle mit ` signal` verbundenen Elemente getrennt. Andernfalls werden nur die Slots im angegebenen Empfänger getrennt. `disconnect()` mit einem von Null verschiedenen ` receiver ` trennt außerdem Slot-Funktionen, die mit ` receiver ` als Kontext-Objekt verbunden waren.

Ist method gleich nullptr, werden alle Verbindungen getrennt, die mit receiver verbunden sind. Andernfalls werden nur Slots mit dem Namen method getrennt, während alle anderen Slots unverändert bleiben. Das method muss nullptr sein, wenn receiver weggelassen wird; daher ist es nicht möglich, einen konkret benannten Slot auf allen Objekten zu trennen.

Hinweis: Diese Funktion ist threadsicher.

Siehe auch ` connect()`.

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

Diese virtuelle Funktion wird aufgerufen, wenn in diesem Objekt eine Verbindung zu signal getrennt wurde.

Ein Beispiel dafür, wie man „ signal “ mit einem bestimmten Signal vergleicht, finden Sie unter „ connectNotify()“.

Wenn alle Signale von diesem Objekt getrennt wurden (z. B. wenn das Signal-Argument von ` disconnect()` ` nullptr` war), wird `disconnectNotify()` nur einmal aufgerufen, und ` signal ` ist ein ungültiger ` QMetaMethod ` (`QMetaMethod::isValid()` gibt ` false` zurück).

Siehe auch „ disconnect()“ und „ connectNotify()“.

void QObject::dumpObjectInfo() const

Gibt Informationen zu Signalverbindungen usw. für dieses Objekt in der Debug-Ausgabe aus.

Siehe auch ` dumpObjectTree()`.

void QObject::dumpObjectTree() const

Gibt eine Baumstruktur der untergeordneten Elemente in der Debug-Ausgabe aus.

Siehe auch ` dumpObjectInfo()`.

QList<QByteArray> QObject::dynamicPropertyNames() const

Gibt die Namen aller Eigenschaften zurück, die dem Objekt mithilfe von ` setProperty()` dynamisch hinzugefügt wurden.

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

Diese virtuelle Funktion empfängt Ereignisse, die an ein Objekt gesendet werden, und sollte „true“ zurückgeben, wenn das Ereignis e erkannt und verarbeitet wurde.

Die Funktion „event()“ kann neu implementiert werden, um das Verhalten eines Objekts anzupassen.

Stellen Sie sicher, dass Sie für alle Ereignisse, die Sie nicht selbst behandelt haben, die Implementierung der übergeordneten Ereignisklasse aufrufen.

Beispiel:

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

Siehe auch „ installEventFilter()“, „ timerEvent()“, „ QCoreApplication::sendEvent()“ und „ QCoreApplication::postEvent()“.

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

Filtert Ereignisse, wenn dieses Objekt als Ereignisfilter für das Objekt „ watched “ installiert wurde.

Wenn Sie in Ihrer Neuimplementierung dieser Funktion das Objekt „ event “ herausfiltern möchten, d. h. verhindern wollen, dass es weiterverarbeitet wird, geben Sie „true“ zurück; andernfalls geben Sie „false“ zurück.

Beispiel:

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 {
        // das Ereignis an die übergeordnete Klasse weiterleiten
        return QMainWindow::eventFilter(obj, event);
    }
}

Beachten Sie im obigen Beispiel, dass nicht verarbeitete Ereignisse an die Funktion `eventFilter()` der Basisklasse weitergeleitet werden, da die Basisklasse `eventFilter()` möglicherweise für ihre eigenen internen Zwecke neu implementiert hat.

Einige Ereignisse, wie z. B. ` QEvent::ShortcutOverride `, müssen explizit akzeptiert werden (durch Aufruf von ` accept()`), um eine Weiterleitung zu verhindern.

Siehe auch ` installEventFilter()`.

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

Gibt das untergeordnete Objekt dieses Objekts zurück, das in den Typ T umgewandelt werden kann und den Namen „ name “ trägt, oder „ nullptr “, falls kein solches Objekt vorhanden ist. Ein Null-Argument für „ name “ führt dazu, dass alle Objekte abgeglichen werden. Ein leeres, nicht-Null-Argument für „ name “ gleicht nur Objekte ab, deren „ objectName “ leer ist. Die Suche wird rekursiv durchgeführt, es sei denn, „ options “ gibt die Option „FindDirectChildrenOnly“ an.

Wenn mehr als ein Kind der Suche entspricht, wird der direkteste Vorfahr zurückgegeben. Gibt es mehrere direkteste Vorfahren, wird das erste Kind in children() zurückgegeben. In diesem Fall ist es besser, findChildren() zu verwenden, um die vollständige Liste aller Kinder zu erhalten.

Dieses Beispiel gibt ein Kind von ` QPushButton ` aus ` parentWidget ` mit dem Namen ` "button1"` zurück, auch wenn die Schaltfläche kein direktes Kind des übergeordneten Elements ist:

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

Dieses Beispiel gibt ein Kind „ QListWidget “ von „ parentWidget “ zurück:

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

Dieses Beispiel gibt ein untergeordnetes Element „ QPushButton “ von „ parentWidget “ (seinem direkten übergeordneten Element) mit dem Namen „ "button1" “ zurück:

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

Dieses Beispiel gibt ein „ QListWidget “-Kind von „ parentWidget “, seinem direkten übergeordneten Element, zurück:

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

Siehe auch „ findChildren()“.

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

Gibt das untergeordnete Objekt dieses Objekts zurück, das in den Typ T umgewandelt werden kann, oder nullptr, falls kein solches Objekt vorhanden ist. Die Suche erfolgt rekursiv, es sei denn, options gibt die Option FindDirectChildrenOnly an.

Wenn mehr als ein Kind der Suche entspricht, wird der direkteste Vorfahr zurückgegeben. Gibt es mehrere direkteste Vorfahren, wird das erste Kind in ` children()` zurückgegeben. In diesem Fall ist es besser, ` findChildren()` zu verwenden, um die vollständige Liste aller Kinder zu erhalten.

Diese Funktion wurde in Qt 6.7 eingeführt.

Siehe auch ` findChildren()`.

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

Gibt alle untergeordneten Objekte dieses Objekts mit dem angegebenen „ name “ zurück, die in den Typ T umgewandelt werden können, oder eine leere Liste, falls keine solchen Objekte vorhanden sind. Ein „ name “-Argument mit dem Wert „null“ führt dazu, dass alle Objekte abgeglichen werden, ein leeres Argument hingegen nur diejenigen, deren „ objectName “ leer ist. Die Suche erfolgt rekursiv, es sei denn, „ options “ gibt die Option „FindDirectChildrenOnly“ an.

Das folgende Beispiel zeigt, wie man eine Liste der untergeordneten „ QWidget“ des angegebenen „ parentWidget “ mit dem Namen „ widgetname “ ermittelt:

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

Dieses Beispiel gibt alle „ QPushButtons“ zurück, die Kinder von „ parentWidget “ sind:

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

Dieses Beispiel gibt alle „ QPushButtons“ zurück, die direkte Unterelemente von „ parentWidget “ sind:

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

Siehe auch findChild().

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

Gibt alle untergeordneten Objekte dieses Objekts zurück, die in den Typ T umgewandelt werden können, oder eine leere Liste, falls keine solchen Objekte vorhanden sind. Die Suche erfolgt rekursiv, es sei denn, unter options ist die Option „FindDirectChildrenOnly“ festgelegt.

Diese Funktion wurde in Qt 6.3 eingeführt.

Siehe auch findChild().

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

Gibt die untergeordneten Objekte dieses Objekts zurück, die in den Typ T umgewandelt werden können und deren Namen dem regulären Ausdruck „ re “ entsprechen, oder eine leere Liste, falls keine solchen Objekte vorhanden sind. Die Suche erfolgt rekursiv, es sei denn, unter „ options “ ist die Option „FindDirectChildrenOnly“ festgelegt.

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

Gibt „ true “ zurück, wenn dieses Objekt eine Instanz einer Klasse ist, die von „ className “ erbt, oder eine Unterklasse von „ QObject “, die von „ className “ erbt; andernfalls wird „ false “ zurückgegeben.

Eine Klasse gilt als sich selbst vererbend.

Beispiel:

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)

Wenn Sie feststellen müssen, ob ein Objekt eine Instanz einer bestimmten Klasse ist, um es umzuwandeln, sollten Sie stattdessen die Funktion ` qobject_cast<Type *>(object)` verwenden.

Siehe auch „ metaObject()“ und „ qobject_cast()“.

void QObject::installEventFilter(QObject *filterObj)

Installiert einen Ereignisfilter „ filterObj “ für dieses Objekt. Beispiel:

monitoredObj->installEventFilter(filterObj);

Ein Ereignisfilter ist ein Objekt, das alle Ereignisse empfängt, die an dieses Objekt gesendet werden. Der Filter kann das Ereignis entweder stoppen oder an dieses Objekt weiterleiten. Der Ereignisfilter filterObj empfängt Ereignisse über seine Funktion eventFilter(). Die Funktion eventFilter() muss „true“ zurückgeben, wenn das Ereignis gefiltert (d. h. gestoppt) werden soll; andernfalls muss sie „false“ zurückgeben.

Sind mehrere Ereignisfilter für ein einzelnes Objekt installiert, wird der zuletzt installierte Filter zuerst aktiviert.

Falls für dieses Objekt bereits „ filterObj “ installiert wurde, verschiebt diese Funktion es so, dass es so wirkt, als wäre es zuletzt installiert worden.

Hier ist eine „ KeyPressEater “-Klasse, die die Tasteneingaben der von ihr überwachten Objekte abfängt:

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

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-Ereignisverarbeitung
        return QObject::eventFilter(obj, event);
    }
}

Und so installierst du es auf zwei Widgets:

KeyPressEater *keyPressEater = new KeyPressEater(this);
QPushButton *pushButton = new QPushButton(this);
QListView *listView = new QListView(this);

pushButton->installEventFilter(keyPressEater);
listView->installEventFilter(keyPressEater);

Die Klasse „ QShortcut “ nutzt diese Technik beispielsweise, um Tastenkombinationen abzufangen.

Beachten Sie, dass sich das Filterobjekt im selben Thread wie dieses Objekt befinden muss. Befindet sich ` filterObj ` in einem anderen Thread, hat diese Funktion keine Auswirkung. Werden entweder ` filterObj ` oder dieses Objekt nach dem Aufruf dieser Funktion in einen anderen Thread verschoben, wird der Ereignisfilter erst dann aufgerufen, wenn beide Objekte wieder dieselbe Thread-Affinität aufweisen (sie wird nicht entfernt).

Siehe auch removeEventFilter(), eventFilter() und event().

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

Gibt zurück, ob das Objekt von der QML-Engine erstellt wurde oder ob die Eigentumsrechte explizit über ` QJSEngine::setObjectOwnership()` festgelegt wurden.

Diese Funktion wurde in Qt 6.11 eingeführt.

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

Gibt „ true “ zurück, wenn das Objekt ein „ QQuickItem “ ist; andernfalls wird „ false “ zurückgegeben.

Der Aufruf dieser Funktion entspricht dem Aufruf von ` inherits("QQuickItem")`, ist jedoch wesentlich schneller.

Diese Funktion wurde in Qt 6.4 eingeführt.

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

Gibt „ true “ zurück, wenn der „ signal “ mit mindestens einem Empfänger verbunden ist; andernfalls wird „ false “ zurückgegeben.

signal muss ein Signal-Element dieses Objekts sein, andernfalls ist das Verhalten undefiniert.

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

Wie der obige Codeausschnitt veranschaulicht, können Sie diese Funktion nutzen, um aufwendige Operationen zu vermeiden oder die Ausgabe eines Signals zu verhindern, auf das niemand hört.

Siehe auch ` receivers()`.

bool QObject::isWidgetType() const

Gibt ` true ` zurück, wenn es sich bei dem Objekt um ein Widget handelt; andernfalls wird ` false` zurückgegeben.

Der Aufruf dieser Funktion entspricht dem Aufruf von ` inherits("QWidget")`, ist jedoch wesentlich schneller.

bool QObject::isWindowType() const

Gibt „ true “ zurück, wenn es sich bei dem Objekt um ein Fenster handelt; andernfalls wird „ false “ zurückgegeben.

Der Aufruf dieser Funktion entspricht dem Aufruf von ` inherits("QWindow")`, ist jedoch wesentlich schneller.

void QObject::killTimer(int id)

Beendet den Timer mit der Timer-ID „ id “.

Die Timer-ID wird von „ startTimer()“ zurückgegeben, wenn ein Timer-Ereignis gestartet wird.

Siehe auch „ timerEvent()“ und „ startTimer()“.

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

Diese Funktion wurde in Qt 6.8 eingeführt.

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

Gibt einen Zeiger auf das Metaobjekt dieses Objekts zurück.

Ein Metaobjekt enthält Informationen über eine Klasse, die von ` QObject` erbt, z. B. Klassenname, Name der Oberklasse, Eigenschaften, Signale und Slots. Jede Unterklasse von ` QObject `, die das Makro ` Q_OBJECT ` enthält, verfügt über ein Metaobjekt.

Die Metaobjekt-Informationen werden vom Signal-/Slot-Verbindungsmechanismus und vom Eigenschaftssystem benötigt. Auch die Funktion ` inherits()` nutzt das Metaobjekt.

Wenn Sie keinen Zeiger auf eine tatsächliche Objektinstanz haben, aber dennoch auf das Metaobjekt einer Klasse zugreifen möchten, können Sie ` staticMetaObject` verwenden.

Beispiel:

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

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

Siehe auch ` staticMetaObject`.

bool QObject::moveToThread(QThread *targetThread)

Ändert die Thread-Affinität für dieses Objekt und seine untergeordneten Objekte und gibt bei Erfolg ` true ` zurück. Das Objekt kann nicht verschoben werden, wenn es ein übergeordnetes Objekt hat. Die Ereignisverarbeitung wird im ` targetThread` fortgesetzt.

Um ein Objekt in den Hauptthread zu verschieben, rufen Sie mit ` QApplication::instance()` einen Zeiger auf die aktuelle Anwendung ab und verwenden Sie anschließend ` QApplication::thread()`, um den Thread zu ermitteln, in dem die Anwendung ausgeführt wird. Beispiel:

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

Wenn ` targetThread ` gleich ` nullptr` ist, wird die gesamte Ereignisverarbeitung für dieses Objekt und seine untergeordneten Objekte angehalten, da sie keinem Thread mehr zugeordnet sind.

Beachten Sie, dass alle aktiven Timer für das Objekt zurückgesetzt werden. Die Timer werden zunächst im aktuellen Thread angehalten und im „ targetThread “ (mit demselben Intervall) neu gestartet. Daher kann das ständige Verschieben eines Objekts zwischen Threads dazu führen, dass Timer-Ereignisse auf unbestimmte Zeit verschoben werden.

Unmittelbar vor der Änderung der Thread-Affinität wird ein „ QEvent::ThreadChange “-Ereignis an dieses Objekt gesendet. Sie können dieses Ereignis verarbeiten, um spezielle Verarbeitungsschritte durchzuführen. Beachten Sie, dass alle neuen Ereignisse, die an dieses Objekt gesendet werden, im „ targetThread “ verarbeitet werden, sofern die „ nullptr “-Einstellung nicht aktiv ist: Wenn „ nullptr “ gesetzt ist, kann keine Ereignisverarbeitung für dieses Objekt oder seine untergeordneten Objekte stattfinden, da diese keinem Thread mehr zugeordnet sind.

In Qt-Versionen vor 6.7 hatte diese Funktion keinen Rückgabewert (void).

Siehe auch thread().

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

Dieses Signal wird ausgelöst, nachdem der Name des Objekts geändert wurde. Der neue Objektname wird als „ objectName “ übergeben.

Siehe auch „ QObject::objectName “.

QObject *QObject::parent() const

Gibt einen Zeiger auf das übergeordnete Objekt zurück.

Siehe auch „ setParent()“ und „ children()“.

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

Gibt den Wert der Eigenschaft „ name “ des Objekts zurück.

Wenn keine solche Eigenschaft vorhanden ist, ist die zurückgegebene Variante ungültig.

Informationen zu allen verfügbaren Eigenschaften werden über die Funktionen „ metaObject()“ und „ dynamicPropertyNames()“ bereitgestellt.

Siehe auch setProperty(), QVariant::isValid(), metaObject() und dynamicPropertyNames().

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

Gibt die Anzahl der an den „ signal “ angeschlossenen Empfänger zurück.

Da sowohl Slots als auch Signale als Empfänger für Signale verwendet werden können und dieselben Verbindungen mehrfach hergestellt werden können, entspricht die Anzahl der Empfänger der Anzahl der von diesem Signal hergestellten Verbindungen.

Beim Aufruf dieser Funktion können Sie das Makro „ SIGNAL() “ verwenden, um ein bestimmtes Signal zu übergeben:

if (receivers(SIGNAL(valueChanged(QByteArray))) > 0) {
    QByteArray data;
    get_the_value(&data);       // expensive operation
    emit valueChanged(data);
}

Wie der obige Codeausschnitt veranschaulicht, können Sie diese Funktion nutzen, um ressourcenintensive Operationen zu vermeiden oder die Ausgabe eines Signals zu verhindern, das von niemandem abgehört wird.

Siehe auch ` isSignalConnected()`.

void QObject::removeEventFilter(QObject *obj)

Entfernt ein Ereignisfilterobjekt „ obj “ aus diesem Objekt. Die Anforderung wird ignoriert, wenn kein solcher Ereignisfilter installiert wurde.

Alle Ereignisfilter für dieses Objekt werden automatisch entfernt, wenn dieses Objekt zerstört wird.

Das Entfernen eines Ereignisfilters ist immer sicher, auch während der Aktivierung des Ereignisfilters (d. h. aus der Funktion ` eventFilter()` heraus).

Siehe auch installEventFilter(), eventFilter() und event().

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

Gibt einen Zeiger auf das Objekt zurück, das das Signal gesendet hat, sofern die Funktion in einem durch ein Signal aktivierten Slot aufgerufen wird; andernfalls wird ` nullptr` zurückgegeben. Der Zeiger ist nur während der Ausführung des Slots gültig, der diese Funktion aus dem Thread-Kontext dieses Objekts aufruft.

Der von dieser Funktion zurückgegebene Zeiger wird ungültig, wenn der Absender zerstört wird oder wenn der Slot vom Signal des Absenders getrennt wird.

Siehe auch ` senderSignalIndex()`.

[protected] int QObject::senderSignalIndex() const

Gibt den Metamethode-Index des Signals zurück, das den aktuell ausgeführten Slot aufgerufen hat, der ein Mitglied der Klasse ist, die von ` sender()` zurückgegeben wird. Wird die Funktion außerhalb eines durch ein Signal aktivierten Slots aufgerufen, wird -1 zurückgegeben.

Bei Signalen mit Standardparametern gibt diese Funktion immer den Index mit allen Parametern zurück, unabhängig davon, welcher bei ` connect()` verwendet wurde. Das Signal ` destroyed(QObject *obj = \nullptr) ` hat beispielsweise zwei verschiedene Indizes (mit und ohne Parameter), doch diese Funktion gibt immer den Index mit einem Parameter zurück. Dies gilt nicht, wenn Signale mit unterschiedlichen Parametern überladen werden.

Siehe auch „ sender()“, „ QMetaObject::indexOfSignal()“ und „ QMetaObject::method()“.

void QObject::setObjectName(const QString &name)

Setzt den Namen des Objekts auf „ name “.

Siehe auch „ objectName()“.

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

Diese Funktion wurde in Qt 6.4 eingeführt.

void QObject::setParent(QObject *parent)

Macht das Objekt zu einem untergeordneten Element von parent.

Siehe auch „ parent()“ und „ children()“.

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

Setzt den Wert der Eigenschaft „ name “ des Objekts auf „ value “.

Wenn die Eigenschaft in der Klasse mit ` Q_PROPERTY ` definiert ist, wird bei Erfolg `true` und andernfalls `false` zurückgegeben. Wenn die Eigenschaft nicht mit ` Q_PROPERTY` definiert ist und daher nicht im Metaobjekt aufgeführt ist, wird sie als dynamische Eigenschaft hinzugefügt und `false` zurückgegeben.

Informationen zu allen verfügbaren Eigenschaften werden über die Methoden ` metaObject()` und ` dynamicPropertyNames()` bereitgestellt.

Dynamische Eigenschaften können erneut mit ` property()` abgefragt und durch Setzen des Eigenschaftswerts auf ein ungültiges ` QVariant` entfernt werden. Das Ändern des Werts einer dynamischen Eigenschaft bewirkt, dass ein ` QDynamicPropertyChangeEvent ` an das Objekt gesendet wird.

Hinweis: Dynamische Eigenschaften, die mit „_q_“ beginnen, sind für interne Zwecke reserviert.

Siehe auch „ property()“, „ metaObject()“, „ dynamicPropertyNames()“ und „ QMetaProperty::write()“.

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

Diese Funktion wurde in Qt 6.6 eingeführt.

[noexcept] bool QObject::signalsBlocked() const

Gibt „ true “ zurück, wenn Signale blockiert sind; andernfalls wird „ false “ zurückgegeben.

Signale werden standardmäßig nicht blockiert.

Siehe auch blockSignals() und QSignalBlocker.

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

Dies ist eine überladene Funktion, die einen Timer vom Typ „ timerType “ mit einer Zeitüberschreitung von „ interval “ Millisekunden startet. Dies entspricht dem Aufruf:

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

Ab Qt 6.10 führt die Angabe eines negativen Intervalls zu einer Laufzeitwarnung, und der Wert wird auf 1 ms zurückgesetzt. Vor Qt 6.10 ließ sich bei einem Qt-Timer zwar ein negatives Intervall festlegen, das Verhalten war jedoch unvorhersehbar (beispielsweise wurde der Timer angehalten, wenn er bereits lief, oder gar nicht erst gestartet).

Siehe auch timerEvent(), killTimer(), QChronoTimer und QBasicTimer.

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

Startet einen Timer und gibt eine Timer-Kennung zurück; falls der Timer nicht gestartet werden konnte, wird Null zurückgegeben.

Ein Timer-Ereignis tritt alle interval auf, bis killTimer() aufgerufen wird. Ist interval gleich std::chrono::duration::zero(), dann tritt das Timer-Ereignis jedes Mal auf, wenn die Steuerung zur Ereignisschleife zurückkehrt, d. h., wenn keine nativen Fenstersystemereignisse mehr zu verarbeiten sind.

Ab Qt 6.10 führt die Festlegung eines negativen Intervalls zu einer Laufzeitwarnung und der Wert wird auf 1 ms zurückgesetzt. Vor Qt 6.10 konnte man bei einem Qt-Timer zwar ein negatives Intervall festlegen, das Verhalten war jedoch unvorhersehbar (beispielsweise wurde der Timer angehalten, wenn er bereits lief, oder gar nicht erst gestartet).

Die virtuelle Funktion ` timerEvent()` wird mit der Ereignisparameterklasse ` QTimerEvent ` aufgerufen, wenn ein Timer-Ereignis eintritt. Implementieren Sie diese Funktion neu, um Timer-Ereignisse abzurufen.

Wenn mehrere Timer laufen, kann die Methode ` QTimerEvent::id()` verwendet werden, um herauszufinden, welcher Timer ausgelöst wurde.

Beispiel:

class MyObject : public QObject
{
    Q_OBJECT

public:
    MyObject(QObject*parent = nullptr);

Q_SIGNALS:
    void valueChanged();

protected:
    void timerEvent(QTimerEvent*event) override;
};

MyObject::MyObject(QObject*parent)
    : QObject(parent)
{
    using namespace std::chrono_literals;

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

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

Beachten Sie, dass die Genauigkeit des Timers vom jeweiligen Betriebssystem und der Hardware abhängt.

Mit dem Argument „ timerType “ können Sie die Genauigkeit des Timers anpassen. Informationen zu den verschiedenen Timer-Typen finden Sie unter Qt::TimerType. Die meisten Plattformen unterstützen eine Genauigkeit von 20 Millisekunden; einige bieten eine höhere Genauigkeit. Wenn Qt die angeforderte Anzahl an Timer-Ereignissen nicht liefern kann, werden einige davon stillschweigend verworfen.

Die Klassen „ QTimer “ und „ QChronoTimer “ bieten eine hochrangige Programmierschnittstelle mit Einmal-Timern und Timer-Signalen anstelle von Ereignissen. Es gibt außerdem die Klasse „ QBasicTimer “, die schlanker ist als „ QChronoTimer “, aber weniger umständlich als die direkte Verwendung von Timer-IDs.

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

Siehe auch „ timerEvent()“, „ killTimer()“, „ QChronoTimer “ und „ QBasicTimer “.

QThread *QObject::thread() const

Gibt den Thread zurück, in dem sich das Objekt befindet.

Siehe auch ` moveToThread()`.

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

Dieser Ereignis-Handler kann in einer Unterklasse neu implementiert werden, um Timer-Ereignisse für das Objekt zu empfangen.

QChronoTimer bietet übergeordnete Schnittstellen zur Timer-Funktionalität sowie allgemeinere Informationen zu Timern. Das Timer-Ereignis wird im Parameter ` event ` übergeben.

Siehe auch „ startTimer()“, „ killTimer()“ und „ event()“.

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

Gibt eine übersetzte Version von sourceText zurück, optional basierend auf einer Zeichenkette aus disambiguation und dem Wert von n für Zeichenketten, die Pluralformen enthalten; andernfalls wird QString::fromUtf8(sourceText) zurückgegeben, wenn keine passende übersetzte Zeichenkette verfügbar ist.

Beispiel:

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

Wenn dieselbe „ sourceText “ in verschiedenen Rollen innerhalb desselben Kontexts verwendet wird, kann eine zusätzliche identifizierende Zeichenfolge in „ disambiguation “ übergeben werden (standardmäßig „nullptr “).

Beispiel:

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

Eine ausführliche Beschreibung der Übersetzungsmechanismen von Qt im Allgemeinen finden Sie unter „Quellcode für die Übersetzung schreiben “, Informationen zur Eindeutigkeitsauflösung im Abschnitt „Eindeutigkeit identischer Texte “.

Siehe auch „ QCoreApplication::translate()“ und „Internationalisierung mit Qt“.