QObject Class

Dokumentation der Mitgliedsfunktionen

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

Konstruiert ein Objekt mit dem übergeordneten Objekt parent.

Das übergeordnete Objekt kann als Eigentümer des Objekts betrachtet werden. Zum Beispiel ist dialog box das übergeordnete Objekt der Schaltflächen OK und Cancel, die es enthält.

Der Destruktor eines übergeordneten Objekts vernichtet alle untergeordneten Objekte.

Wenn Sie parent auf nullptr setzen, wird ein Objekt ohne Elternteil erzeugt. Wenn das Objekt ein Widget ist, wird es zu einem Fenster der obersten Ebene.

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

[virtual noexcept] QObject::~QObject()

Zerstört das Objekt und löscht alle seine untergeordneten Objekte.

Alle Signale an und von dem Objekt werden automatisch unterbrochen, und alle ausstehenden Ereignisse für das Objekt werden aus der Ereigniswarteschlange entfernt. Es ist jedoch oft sicherer, deleteLater() zu verwenden, als eine QObject Unterklasse direkt zu löschen.

Siehe auch deleteLater().

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

Wenn block wahr ist, werden die von diesem Objekt ausgesandten Signale blockiert (d. h. das Aussenden eines Signals ruft nichts auf, was mit ihm verbunden ist). Wenn block false ist, 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 für dieses Objekt blockiert wurden.

Signale, die während einer Blockierung ausgegeben werden, werden nicht gepuffert.

Siehe auch signalsBlocked() und QSignalBlocker.

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

Dieser Event-Handler kann in einer Unterklasse neu implementiert werden, um untergeordnete Ereignisse zu empfangen. Das Ereignis wird mit dem Parameter event übergeben.

QEvent::ChildAdded und QEvent::ChildRemoved Ereignisse werden an Objekte gesendet, wenn Kinder hinzugefügt oder entfernt werden. In beiden Fällen können Sie sich nur darauf verlassen, dass das Kind ein QObject ist, oder, wenn isWidgetType() true zurückgibt, ein QWidget. (Das liegt daran, dass im Fall von ChildAdded das Kind noch nicht vollständig konstruiert ist, und im Fall von ChildRemoved könnte es bereits zerstört worden sein).

QEvent::ChildPolished Ereignisse werden an Widgets gesendet, wenn Kinder poliert werden oder wenn polierte Kinder hinzugefügt werden. Wenn Sie ein poliertes Kind-Ereignis erhalten, ist die Konstruktion des Kindes normalerweise abgeschlossen. Dies ist jedoch nicht garantiert, und es können mehrere Polishing-Ereignisse während der Ausführung des Konstruktors eines Widgets eintreffen.

Für jedes untergeordnete Widget erhalten Sie ein ChildAdded Ereignis, null oder mehr ChildPolished Ereignisse und ein ChildRemoved Ereignis.

Das ChildPolished Ereignis wird ausgelassen, wenn ein untergeordnetes Widget unmittelbar nach dem Hinzufügen entfernt wird. Wenn ein untergeordnetes Widget während des Aufbaus und der Zerstörung mehrmals poliert wird, können Sie mehrere polierte 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 Unterobjekten zurück. Die Klasse QObjectList ist in der Header-Datei <QObject> wie folgt definiert:

typedef QList<QObject*> QObjectList;

Das erste hinzugefügte Kind ist das first Objekt in der Liste und das letzte hinzugefügte Kind ist das last Objekt in der Liste, d.h. neue Kinder werden am Ende angehängt.

Beachten Sie, dass sich die Reihenfolge der Liste ändert, wenn QWidget Kinder 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)

Erzeugt eine Verbindung der angegebenen type vom signal im sender Objekt zum method im receiver Objekt. Gibt ein Handle für die Verbindung zurück, das später zum Trennen der Verbindung verwendet werden kann.

Das Verbindungshandle ist ungültig, wenn die Verbindung nicht hergestellt werden kann, z. B. weil die Parameter ungültig waren. Sie können prüfen, ob QMetaObject::Connection gültig ist, indem Sie es in ein bool umwandeln.

Diese Funktion arbeitet auf die gleiche Weise wie connect(const QObject *sender, const char *signal, const QObject *receiver, const char *method, Qt::ConnectionType type), verwendet aber 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)

Erzeugt eine Verbindung der angegebenen type vom signal im sender Objekt zum method im receiver Objekt. Gibt ein Handle für die Verbindung zurück, mit dem sie später wieder getrennt werden kann.

Sie müssen die Makros SIGNAL() und SLOT() verwenden, wenn Sie z. B. signal und method angeben:

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

Dieses Beispiel stellt sicher, dass das Etikett immer den aktuellen Wert der Bildlaufleiste anzeigt. Beachten Sie, dass die Parameter signal und slots keine Variablennamen enthalten dürfen, sondern nur den Typ. Das folgende Beispiel würde z.B. 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 Mitgliedsvariablen weiter und stellt es unter einem Namen zur Verfügung, der sich auf MyWidget bezieht.

Ein Signal kann mit vielen Slots und Signalen verbunden werden. Viele Signale können mit einem Slot verbunden sein.

Wenn ein Signal mit mehreren Slots verbunden ist, werden die Slots in der gleichen Reihenfolge aktiviert, in der die Verbindungen hergestellt wurden, wenn das Signal ausgesendet wird.

Die Funktion gibt ein QMetaObject::Connection zurück, das ein Handle zu einer Verbindung darstellt, wenn sie das Signal erfolgreich mit dem Slot verbindet. Das Verbindungshandle ist ungültig, wenn die Verbindung nicht hergestellt werden kann, z. B. wenn QObject nicht in der Lage ist, die Existenz von signal oder method zu überprüfen, oder wenn ihre Signaturen nicht kompatibel sind. Sie können prüfen, ob das Handle gültig ist, indem Sie es in ein bool umwandeln.

Standardmäßig wird für jede Verbindung, die Sie herstellen, ein Signal ausgegeben; für doppelte Verbindungen werden zwei Signale ausgegeben. Sie können alle diese Verbindungen mit einem einzigen disconnect()-Aufruf unterbrechen. Wenn Sie Qt::UniqueConnection type übergeben, wird die Verbindung nur hergestellt, wenn es sich nicht um ein Duplikat handelt. Wenn es bereits ein Duplikat gibt (genau dasselbe Signal an genau denselben Slot auf denselben Objekten), wird die Verbindung fehlschlagen und connect gibt ein ungültiges QMetaObject::Connection zurück.

Der optionale Parameter type beschreibt die Art der Verbindung, die hergestellt werden soll. Er bestimmt insbesondere, ob ein bestimmtes Signal sofort an einen Slot geliefert wird oder ob es in eine Warteschlange gestellt wird, um zu einem späteren Zeitpunkt geliefert zu werden. Wenn das Signal in eine Warteschlange gestellt wird, müssen die Parameter von Typen sein, die dem Meta-Objektsystem von Qt bekannt sind, da Qt die Argumente kopieren muss, um sie in einem Ereignis hinter den Kulissen zu speichern. Wenn Sie versuchen, eine Warteschlangenverbindung zu benutzen und die Fehlermeldung erhalten

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 thread-sicher.

Siehe auch disconnect(), sender(), qRegisterMetaType(), Q_DECLARE_METATYPE(), und Unterschiede zwischen String-basierten und Functor-basierten Verbindungen.

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

Diese Funktion überlastet connect().

Erstellt eine Verbindung von signal im sender Objekt zu functor und gibt ein Handle auf 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 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();
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 Absender zerstört wird. Sie sollten jedoch darauf achten, dass alle Objekte, die im Funktor verwendet werden, noch am Leben sind, wenn das Signal ausgesendet wird.

Aus diesem Grund ist es empfehlenswert, die Überladung von connect() zu verwenden, die ebenfalls ein QObject als Empfänger/Kontext annimmt. Es ist möglich, die Verwendung der kontextlosen Überladung zu deaktivieren, indem man das Makro QT_NO_CONTEXTLESS_CONNECT definiert.

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

Hinweis: Diese Funktion ist thread-sicher.

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

Diese Funktion überlastet connect().

Verbindet signal vom Objekt sender mit dem method dieses Objekts.

Äquivalent zu connect(sender, signal, this, method, type).

Jede Verbindung, die Sie herstellen, gibt ein Signal aus, so dass doppelte Verbindungen zwei Signale ausgeben. Sie können eine Verbindung mit disconnect() unterbrechen.

Hinweis: Diese Funktion ist thread-sicher.

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)

Diese Funktion überlastet connect().

Erstellt eine Verbindung von einem gegebenen type von signal in sender Objekt zu functor, um in einer bestimmten Ereignisschleife von context platziert zu werden, und gibt ein Handle auf die Verbindung zurück.

Das Signal muss eine Funktion sein, die im Header als Signal deklariert ist. Die Slot-Funktion kann jede Funktion oder jeder 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();
QPushButton *button = new QPushButton;
QObject::connect(button, &QPushButton::clicked, this, someFunction, Qt::QueuedConnection);

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, 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 Objekte, die innerhalb des Funktors verwendet werden, noch am Leben sind, wenn das Signal ausgegeben wird.

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

Hinweis: Diese Funktion ist thread-sicher.

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

Diese Funktion überlastet connect().

Erzeugt eine Verbindung des angegebenen type vom signal im sender Objekt zum method im receiver Objekt. Sie gibt einen Handle auf die Verbindung zurück, der später zum Trennen der Verbindung verwendet werden kann.

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

Beispiel:

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

Dieses Beispiel stellt sicher, dass das Etikett immer den aktuellen Zeilentext anzeigt.

Ein Signal kann mit vielen Slots und Signalen verbunden werden. Viele Signale können mit einem Slot verbunden werden.

Wenn ein Signal mit mehreren Slots verbunden ist, werden die Slots in der gleichen Reihenfolge aktiviert, in der die Verbindung hergestellt wurde, wenn das Signal ausgegeben wird

Die Funktion gibt ein Handle zu einer Verbindung zurück, wenn sie das Signal erfolgreich mit dem Slot verbindet. Das Verbindungshandle ist ungültig, wenn die Verbindung nicht hergestellt werden kann, z. B. wenn QObject nicht in der Lage ist, die Existenz von signal zu überprüfen (wenn es nicht als Signal deklariert wurde). Sie können überprüfen, ob QMetaObject::Connection gültig ist, indem Sie es in ein bool umwandeln.

Standardmäßig wird für jede Verbindung, die Sie herstellen, ein Signal ausgegeben; für doppelte Verbindungen werden zwei Signale ausgegeben. Sie können alle diese Verbindungen mit einem einzigen disconnect()-Aufruf unterbrechen. Wenn Sie Qt::UniqueConnection type übergeben, wird die Verbindung nur hergestellt, wenn es sich nicht um ein Duplikat handelt. Wenn es bereits ein Duplikat gibt (genau dasselbe Signal an genau denselben Slot auf 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 Verbindung, die aufgebaut werden soll. Er bestimmt insbesondere, ob ein bestimmtes Signal sofort an einen Steckplatz geliefert wird oder ob es in eine Warteschlange gestellt wird, um zu einem späteren Zeitpunkt geliefert zu werden. Wenn das Signal in eine Warteschlange gestellt wird, müssen die Parameter von Typen sein, die dem Meta-Objektsystem von Qt bekannt sind, da Qt die Argumente kopieren muss, um sie in einem Ereignis hinter den Kulissen zu speichern. Wenn Sie versuchen, eine Warteschlangenverbindung zu verwenden und die Fehlermeldung erhalten

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

erhalten, stellen Sie sicher, dass Sie den Argumenttyp mit Q_DECLARE_METATYPE

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

Hinweis: Diese Funktion ist thread-sicher.

Siehe auch Unterschiede zwischen String-basierten und Functor-basierten Verbindungen.

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

Diese virtuelle Funktion wird aufgerufen, wenn in diesem Objekt etwas mit signal verbunden wurde.

Wenn Sie signal mit einem bestimmten Signal vergleichen wollen, 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 Event-Handler kann in einer Unterklasse neu implementiert werden, um benutzerdefinierte Ereignisse zu empfangen. Benutzerdefinierte Ereignisse sind benutzerdefinierte Ereignisse mit einem Typwert, der mindestens so groß ist wie das Element QEvent::User der Aufzählung QEvent::Type, und typischerweise eine QEvent Unterklasse ist. Das Ereignis wird mit dem Parameter event übergeben.

Siehe auch event() und QEvent.

[slot] void QObject::deleteLater()

Plant die Löschung dieses Objekts.

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

Beachten Sie, dass das Betreten und Verlassen einer neuen Ereignisschleife (z.B. durch das Öffnen eines modalen Dialogs) das aufgeschobene Löschen nicht durchführt; damit das Objekt gelöscht wird, muss die Kontrolle 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 beginnt.

In Situationen, in denen Qt den Event-Dispatcher nicht über z.B. QCoreApplication::exec() oder QEventLoop::exec() ansteuert, werden aufgeschobene Löschungen nicht automatisch verarbeitet. Um eine verzögerte Löschung in diesem Szenario zu gewährleisten, kann der folgende Workaround 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 thread-safe.

Siehe auch destroyed() und QPointer.

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

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

Alle Kinder des Objekts werden unmittelbar nach dem Aussenden dieses Signals zerstört.

Siehe auch deleteLater() und QPointer.

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

Trennen Sie eine Verbindung.

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

Siehe auch 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 unterbrochen wurde; andernfalls false.

Diese Funktion bietet die gleichen Möglichkeiten wie disconnect(const QObject *sender, const char *signal, const QObject *receiver, const char *method), verwendet aber QMetaMethod, um das Signal und die zu trennende Methode darzustellen.

Zusätzlich gibt diese Funktion false und keine Signale und Slots zurück, wenn die Verbindung getrennt wurde:

1. signal kein Mitglied der Absenderklasse oder einer ihrer Elternklassen ist.
2. method kein Mitglied der Empfängerklasse oder einer ihrer Elternklassen ist.
3. signal die Instanz kein Signal darstellt.

Um Unstimmigkeiten zu vermeiden, speichern Sie das von connect() zurückgegebene Verbindungshandle und verwenden Sie es im Aufruf von disconnect().

QMetaMethod() kann als Platzhalter in der Bedeutung "jedes Signal" oder "jeder Slot im empfangenden Objekt" verwendet werden. In gleicher Weise kann nullptr für receiver in der Bedeutung "beliebiges Empfangsobjekt" verwendet werden. In diesem Fall sollte die Methode auch QMetaMethod() sein. Der Parameter sender sollte niemals nullptr sein.

Siehe auch disconnect(const QObject *Sender, const char *Signal, const QObject *Empfänger, const char *Methode).

[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 false.

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. Trennen Sie alles, was mit den Signalen eines Objekts verbunden ist:

   disconnect(myObject, nullptr, nullptr, nullptr);

   Äquivalent zur nicht-statischen überladenen Funktion

   myObject->disconnect();

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

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

   Äquivalent zur nicht statischen überladenen Funktion

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

3. Trennen Sie einen bestimmten Empfänger:

   disconnect(myObject, nullptr, myReceiver, nullptr);

   Äquivalent zu der nicht statischen überladenen Funktion

   myObject->disconnect(myReceiver);

Um Unstimmigkeiten zu vermeiden, speichern Sie das von connect() zurückgegebene Verbindungshandle und verwenden Sie es im Aufruf von disconnect().

nullptr kann als Platzhalter verwendet werden, was "jedes Signal", "jedes empfangende Objekt" bzw. "jeder Slot im empfangenden Objekt" bedeutet.

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

Wenn signal nullptr ist, wird die Verbindung zwischen receiver und method von jedem Signal getrennt. Wenn nicht, wird nur das angegebene Signal getrennt.

Wenn receiver gleich nullptr ist, wird die Verbindung zu signal unterbrochen, andernfalls werden Slots in anderen Objekten als receiver nicht unterbrochen.

Wenn method nullptr ist, wird die Verbindung zu receiver unterbrochen. Wenn nicht, werden nur die Slots mit dem Namen method unterbrochen, alle anderen Slots bleiben unberührt. method muss nullptr sein, wenn receiver ausgelassen wird, so dass Sie nicht bei allen Objekten einen speziell benannten Steckplatz abschalten können.

Hinweis: Diese Funktion ist thread-sicher.

Siehe auch connect().

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

Diese Funktion überlastet disconnect().

Trennt alle Signale in diesem Objekt von receiver's method.

Um Fehlanpassungen zu vermeiden, speichern Sie das von connect() zurückgegebene Verbindungshandle und verwenden Sie es im 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

Diese Funktion überlädt disconnect().

Trennt die Verbindung zwischen signal und method von receiver.

Um Fehlanpassungen zu vermeiden, speichern Sie das von connect() zurückgegebene Verbindungshandle und verwenden Sie es im Aufruf von disconnect().

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

Hinweis: Diese Funktion ist thread-sicher.

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

Diese Funktion überlastet disconnect().

Trennt die Verbindung zwischen signal im Objekt sender und method im Objekt receiver. Gibt true zurück, wenn die Verbindung erfolgreich getrennt wurde; andernfalls false.

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. Trennen Sie alles, was mit den Signalen eines Objekts verbunden ist:

   disconnect(myObject, nullptr, nullptr, nullptr);

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

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

3. Trennen Sie einen bestimmten Empfänger:

   disconnect(myObject, nullptr, myReceiver, nullptr);

4. Trennen Sie eine Verbindung von einem bestimmten Signal zu einem bestimmten Steckplatz:

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

nullptr kann als Platzhalter verwendet werden und bedeutet "jedes Signal", "jedes empfangende Objekt" bzw. "jeder Steckplatz im empfangenden Objekt".

sender darf niemals nullptr sein. (Es ist nicht möglich, Signale von mehr als einem Objekt in einem einzigen Aufruf zu trennen.)

Wenn signal nullptr ist, wird die Verbindung zwischen receiver und method von jedem Signal getrennt. Wenn nicht, wird nur das angegebene Signal getrennt.

Wenn receiver nullptr ist, wird die Verbindung zu signal unterbrochen, andernfalls werden nur die Slots des angegebenen Empfängers unterbrochen. disconnect() mit einem receiver, der nicht Null ist, unterbricht auch die Verbindung von Slot-Funktionen, die mit receiver als Kontextobjekt verbunden waren.

Wenn method nullptr ist, wird alles getrennt, was mit receiver verbunden ist. Wenn nicht, werden nur Slots mit dem Namen method getrennt und alle anderen Slots werden in Ruhe gelassen. method muss nullptr sein, wenn receiver ausgelassen wird, so dass Sie nicht bei allen Objekten einen speziell benannten Slot abschalten können.

Hinweis: Diese Funktion ist thread-sicher.

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.

Siehe connectNotify() für ein Beispiel, wie man signal mit einem bestimmten Signal vergleicht.

Wenn alle Signale von diesem Objekt getrennt wurden (z. B. war das Signalargument für disconnect() nullptr), wird disconnectNotify() nur einmal aufgerufen, und signal ist ein ungültiges QMetaMethod (QMetaMethod::isValid() gibt false zurück ).

Siehe auch disconnect() und connectNotify().

void QObject::dumpObjectInfo() const

Gibt Informationen über Signalverbindungen usw. für dieses Objekt in die Debug-Ausgabe aus.

Siehe auch dumpObjectTree().

void QObject::dumpObjectTree() const

Gibt einen Baum von Kindern in die Debug-Ausgabe aus.

Siehe auch dumpObjectInfo().

QList<QByteArray> QObject::dynamicPropertyNames() const

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

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

Diese virtuelle Funktion empfängt Ereignisse zu einem Objekt 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 die Implementierung der übergeordneten Ereignisklasse für alle Ereignisse aufrufen, die Sie nicht verarbeitet haben.

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 event herausfiltern wollen, d. h. die weitere Bearbeitung verhindern wollen, 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; }; HauptFenster::HauptFenster() { textEdit = new QTextEdit; setCentralWidget(textEdit);  textEdit->installEventFilter(this); }bool HauptFenster::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 weitergeben return QMainWindow::eventFilter(obj, event); } }

Beachten Sie im obigen Beispiel, dass unbehandelte Ereignisse an die Funktion eventFilter() der Basisklasse weitergegeben werden, da die Basisklasse eventFilter() für ihre eigenen internen Zwecke reimplementiert haben könnte.

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

Siehe auch installEventFilter().

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

Gibt das Kind dieses Objekts zurück, das in den Typ T gecastet werden kann und das name heißt, oder nullptr, wenn es kein solches Objekt gibt. Ein Null-Argument name bewirkt, dass alle Objekte abgeglichen werden. Ein leeres, nicht-null name passt nur auf Objekte, deren objectName leer ist. Die Suche wird rekursiv durchgeführt, es sei denn, options gibt die Option FindDirectChildrenOnly an.

Wenn es mehr als ein Kind gibt, das der Suche entspricht, wird der direkteste Vorfahre zurückgegeben. Wenn es mehrere direkte Vorfahren gibt, 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 untergeordnetes Element QPushButton von parentWidget mit dem Namen "button1" zurück, auch wenn die Schaltfläche kein direktes untergeordnetes Element des übergeordneten Elements ist:

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

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

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

Dieses Beispiel gibt ein Kind QPushButton von parentWidget (seinem direkten Elternteil) mit dem Namen "button1" zurück:

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

Dieses Beispiel gibt ein QListWidget Kind von parentWidget zurück, dessen direktes Elternteil:

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

Dies ist eine überladene Funktion.

Gibt das Kind dieses Objekts zurück, das in den Typ T gecastet werden kann, oder nullptr, wenn es kein solches Objekt gibt. Die Suche wird rekursiv durchgeführt, es sei denn, options gibt die Option FindDirectChildrenOnly an.

Wenn es mehr als ein Kind gibt, das der Suche entspricht, wird der direkteste Vorfahre zurückgegeben. Wenn es mehrere direkte Vorfahren gibt, wird das erste Kind in children() zurückgegeben. In diesem Fall ist es besser, findChildren() zu verwenden, um die komplette 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 Kinder dieses Objekts mit dem angegebenen name zurück, die auf den Typ T gecastet werden können, oder eine leere Liste, wenn es keine solchen Objekte gibt. Ein Null-Argument name bewirkt, dass alle Objekte gefunden werden, ein leeres Argument nur solche, deren objectName leer ist. Die Suche wird rekursiv durchgeführt, es sei denn options gibt die Option FindDirectChildrenOnly an.

Das folgende Beispiel zeigt, wie man eine Liste der untergeordneten QWidgets des angegebenen parentWidget mit dem Namen widgetname findet:

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 unmittelbare Kinder 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

Dies ist eine überladene Funktion.

Gibt alle Kinder dieses Objekts zurück, die auf den Typ T gecastet werden können, oder eine leere Liste, wenn es keine solchen Objekte gibt. Die Suche wird rekursiv durchgeführt, es sei denn options gibt die Option FindDirectChildrenOnly an.

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

Diese Funktion überlastet findChildren().

Gibt die Kinder dieses Objekts zurück, die auf den Typ T gecastet werden können und deren Namen dem regulären Ausdruck re entsprechen, oder eine leere Liste, wenn es keine solchen Objekte gibt. Die Suche wird rekursiv durchgeführt, es sei denn, options gibt die Option FindDirectChildrenOnly an.

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

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

Es wird davon ausgegangen, dass eine Klasse sich selbst vererbt.

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 zu casten, sollten Sie stattdessen qobject_cast<Type *>(object) verwenden.

Siehe auch metaObject() und qobject_cast().

void QObject::installEventFilter(QObject *filterObj)

Installiert einen Ereignisfilter filterObj auf diesem Objekt. Zum Beispiel:

monitoredObj->installEventFilter(filterObj);

Ein Ereignisfilter ist ein Objekt, das alle Ereignisse empfängt, die an dieses Objekt gesendet werden. Der Filter kann entweder das Ereignis stoppen oder es 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.

Wenn mehrere Ereignisfilter auf einem Objekt installiert sind, wird der zuletzt installierte Filter zuerst aktiviert.

Wenn filterObj bereits für dieses Objekt installiert wurde, verschiebt diese Funktion es so, als ob es zuletzt installiert wurde.

Hier ist eine Klasse KeyPressEater, die die Tastendrücke ihrer überwachten Objekte aufnimmt:

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

Und hier ist, wie man es auf zwei Widgets installiert:

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

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

Die Klasse QShortcut zum Beispiel verwendet diese Technik, um Tastenkombinationen abzufangen.

Beachten Sie, dass sich das filternde Objekt im selben Thread wie dieses Objekt befinden muss. Wenn filterObj in einem anderen Thread ist, macht diese Funktion nichts. Wenn entweder filterObj oder dieses Objekt nach dem Aufruf dieser Funktion in einen anderen Thread verschoben werden, wird der Ereignisfilter nicht aufgerufen, bis beide Objekte wieder die gleiche Thread-Affinität haben (er wird nicht entfernt).

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

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

Gibt true zurück, wenn das Objekt ein QQuickItem ist; andernfalls gibt es false zurück.

Der Aufruf dieser Funktion ist äquivalent zum Aufruf von inherits("QQuickItem"), mit dem Unterschied, dass er viel schneller ist.

Diese Funktion wurde in Qt 6.4 eingeführt.

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

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

signal muss ein Signalmitglied dieses Objekts sein, ansonsten ist das Verhalten undefiniert.

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

Wie der obige Codeschnipsel zeigt, können Sie diese Funktion verwenden, um eine teure Initialisierung oder das Aussenden eines Signals zu vermeiden, auf das niemand hört. In einer Multithreading-Anwendung können sich die Verbindungen jedoch ändern, nachdem diese Funktion zurückkehrt und bevor das Signal ausgegeben wird.

bool QObject::isWidgetType() const

Gibt true zurück, wenn das Objekt ein Widget ist; andernfalls false.

Der Aufruf dieser Funktion ist äquivalent zum Aufruf von inherits("QWidget"), nur dass er viel schneller ist.

bool QObject::isWindowType() const

Gibt true zurück, wenn das Objekt ein Fenster ist; andernfalls false.

Der Aufruf dieser Funktion ist äquivalent zum Aufruf von inherits("QWindow"), nur dass er viel schneller ist.

void QObject::killTimer(int id)

Beendet den Zeitgeber mit der Zeitgeberkennung id.

Die Zeitgeberkennung wird von startTimer() zurückgegeben, wenn ein Zeitgeberereignis gestartet wird.

Siehe auch timerEvent() und startTimer().

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

Dies ist eine überladene Funktion.

Diese Funktion wurde in Qt 6.8 eingeführt.

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

Gibt einen Zeiger auf das Meta-Objekt dieses Objekts zurück.

Ein Meta-Objekt enthält Informationen über eine Klasse, die QObject erbt, z. B. Klassenname, Oberklassenname, Eigenschaften, Signale und Slots. Jede QObject Unterklasse, die das Makro Q_OBJECT enthält, hat ein Meta-Objekt.

Die Meta-Objekt-Informationen werden für den Signal/Slot-Verbindungsmechanismus und das Eigenschaftssystem benötigt. Die Funktion inherits() macht ebenfalls Gebrauch vom Meta-Objekt.

Wenn Sie keinen Zeiger auf eine tatsächliche Objektinstanz haben, aber dennoch auf das Meta-Objekt einer Klasse zugreifen wollen, 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 Kinder und gibt bei Erfolg true zurück. Das Objekt kann nicht verschoben werden, wenn es einen Elternteil hat. Die Ereignisverarbeitung wird im targetThread fortgesetzt.

Um ein Objekt in den Haupt-Thread zu verschieben, verwenden Sie QApplication::instance(), um einen Zeiger auf die aktuelle Anwendung abzurufen, und verwenden Sie dann QApplication::thread(), um den Thread abzurufen, in dem sich die Anwendung befindet. Ein Beispiel:

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

Wenn targetThread nullptr ist, wird die gesamte Ereignisverarbeitung für dieses Objekt und seine Kinder gestoppt, da sie keinem Thread mehr zugeordnet sind.

Beachten Sie, dass alle aktiven Zeitgeber für das Objekt zurückgesetzt werden. Die Zeitgeber werden zunächst im aktuellen Thread angehalten und im targetThread neu gestartet (mit demselben Intervall). Daher kann das ständige Verschieben eines Objekts zwischen Threads die Zeitgeberereignisse auf unbestimmte Zeit verschieben.

Ein QEvent::ThreadChange Ereignis wird an dieses Objekt gesendet, kurz bevor die Thread-Affinität geändert wird. Sie können dieses Ereignis behandeln, um eine spezielle Verarbeitung durchzuführen. Beachten Sie, dass alle neuen Ereignisse, die an dieses Objekt gesendet werden, im targetThread verarbeitet werden, sofern es nicht nullptr ist: Wenn es nullptr ist, kann keine Ereignisverarbeitung für dieses Objekt oder seine Kinder stattfinden, da sie nicht mehr mit einem Thread verbunden sind.

Siehe auch thread().

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

Dieses Signal wird ausgegeben, nachdem der Name des Objekts geändert worden ist. 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 existiert, ist die zurückgegebene Variante ungültig.

Informationen über alle 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 mit signal verbundenen Empfänger zurück.

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

Wenn Sie diese Funktion aufrufen, 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);
}

Siehe auch isSignalConnected().

void QObject::removeEventFilter(QObject *obj)

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

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

Es ist immer sicher, einen Ereignisfilter zu entfernen, auch während der Aktivierung des Ereignisfilters (d.h. von der Funktion eventFilter()).

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

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

Gibt einen Zeiger auf das Objekt zurück, das das Signal gesendet hat, wenn es in einem durch ein Signal aktivierten Slot aufgerufen wird; andernfalls gibt es nullptr zurück. 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 Index der Metamethode des Signals zurück, das den aktuell ausgeführten Slot aufgerufen hat, der ein Mitglied der von sender() zurückgegebenen Klasse ist. Wird es außerhalb eines durch ein Signal aktivierten Slots aufgerufen, wird -1 zurückgegeben.

Für Signale mit Standardparametern gibt diese Funktion immer den Index mit allen Parametern zurück, unabhängig davon, welcher mit connect() verwendet wurde. Zum Beispiel hat das Signal destroyed(QObject *obj = \nullptr) zwei verschiedene Indizes (mit und ohne Parameter), aber diese Funktion gibt immer den Index mit einem Parameter zurück. Dies gilt nicht für das Überladen von Signalen mit verschiedenen Parametern.

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)

Dies ist eine überladene Funktion.

Diese Funktion wurde in Qt 6.4 eingeführt.

void QObject::setParent(QObject *parent)

Macht das Objekt zu einem Kind 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 zurückgegeben, andernfalls false. Wenn die Eigenschaft nicht über Q_PROPERTY definiert und daher nicht im Metaobjekt aufgeführt ist, wird sie als dynamische Eigenschaft hinzugefügt und false zurückgegeben.

Informationen über alle verfügbaren Eigenschaften werden über die Befehle metaObject() und dynamicPropertyNames() bereitgestellt.

Dynamische Eigenschaften können mit property() erneut abgefragt und durch Setzen des Eigenschaftswerts auf einen ungültigen QVariant entfernt werden. Die Änderung des Werts einer dynamischen Eigenschaft bewirkt, dass eine 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 überlastet setProperty.

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 sind 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 des Typs timerType und ein Timeout von interval Millisekunden startet. Dies ist gleichbedeutend mit einem Aufruf:

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

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

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

Dies ist eine überladene Funktion.

Startet einen Zeitgeber und gibt eine Zeitgeberkennung zurück, oder gibt Null zurück, wenn kein Zeitgeber gestartet werden konnte.

Ein Timer-Ereignis tritt jedes Mal auf interval, bis killTimer() aufgerufen wird. Wenn interval gleich std::chrono::duration::zero() ist, tritt das Timer-Ereignis jedes Mal auf, wenn keine weiteren Fenstersystemereignisse zu verarbeiten sind.

Die virtuelle Funktion timerEvent() wird mit der Ereignisparameterklasse QTimerEvent aufgerufen, wenn ein Timer-Ereignis eintritt. Reimplementieren Sie diese Funktion, um Timer-Ereignisse zu erhalten.

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

Beispiel:

class MyObject : public QObject
{ Q_OBJECTpublic: MyObject(QObject *parent = nullptr);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 *Ereignis){
    qDebug() << "Timer ID:" << event->id();
}

Beachten Sie, dass die Genauigkeit des Zeitgebers vom zugrunde liegenden Betriebssystem und der Hardware abhängt.

Mit dem Argument timerType können Sie die Genauigkeit des Zeitgebers anpassen. Siehe Qt::TimerType für Informationen über die verschiedenen Timer-Typen. Die meisten Plattformen unterstützen eine Genauigkeit von 20 Millisekunden, einige bieten mehr. Wenn Qt nicht in der Lage ist, die angeforderte Anzahl von Timer-Ereignissen zu liefern, wird es einige stillschweigend verwerfen.

Die Klassen QTimer und QChronoTimer bieten eine High-Level-Programmierschnittstelle mit Single-Shot-Timern und Timer-Signalen anstelle von Ereignissen. Es gibt auch eine Klasse QBasicTimer, die leichter 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 Event-Handler kann in einer Unterklasse neu implementiert werden, um Timer-Ereignisse für das Objekt zu empfangen.

QChronoTimer bietet Schnittstellen auf höherer Ebene zur Timer-Funktionalität und auch allgemeinere Informationen über Timer. Das Timer-Ereignis wird mit dem 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 disambiguation Zeichenkette und dem Wert von n für Zeichenketten, die Plurale enthalten; andernfalls wird QString::fromUtf8(sourceText) zurückgegeben, wenn keine entsprechende ü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 Identifizierungszeichenfolge in disambiguation (nullptr standardmäßig) übergeben werden.

Beispiel:

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

Siehe Writing Source Code for Translation für eine detaillierte Beschreibung der Übersetzungsmechanismen von Qt im Allgemeinen und den Abschnitt Disambiguate Identical Text für Informationen zur Disambiguierung.

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