Back to Qt.io
Contact Us Blog Download Qt

QTimer Class

Die Klasse QTimer bietet Zeitgeber für Wiederholungen und Einzelaufnahmen. Mehr...

Kopfzeile: #include <QTimer>
CMake: find_package(Qt6 REQUIRED COMPONENTS Core)
target_link_libraries(mytarget PRIVATE Qt6::Core)
qmake: QT += core
Vererbt: QObject

Eigenschaften

Öffentliche Funktionen

QTimer(QObject *parent = nullptr)
virtual ~QTimer()
QBindable<bool> bindableActive()
QBindable<int> bindableInterval()
QBindable<bool> bindableSingleShot()
QBindable<Qt::TimerType> bindableTimerType()
QMetaObject::Connection callOnTimeout(Functor &&slot)
QMetaObject::Connection callOnTimeout(const QObject *context, Functor &&slot, Qt::ConnectionType connectionType = Qt::AutoConnection)
(since 6.8) Qt::TimerId id() const
int interval() const
std::chrono::milliseconds intervalAsDuration() const
bool isActive() const
bool isSingleShot() const
int remainingTime() const
std::chrono::milliseconds remainingTimeAsDuration() const
void setInterval(int msec)
void setInterval(std::chrono::milliseconds value)
void setSingleShot(bool singleShot)
void setTimerType(Qt::TimerType atype)
void start(std::chrono::milliseconds msec)
int timerId() const
Qt::TimerType timerType() const

Öffentliche Slots

void start(int msec)
void start()
void stop()

Signale

void timeout()

Statische öffentliche Mitglieder

void singleShot(Duration interval, Functor &&functor)
void singleShot(Duration interval, Qt::TimerType timerType, Functor &&functor)
void singleShot(Duration interval, const QObject *context, Functor &&functor)
void singleShot(Duration interval, Qt::TimerType timerType, const QObject *context, Functor &&functor)
void singleShot(std::chrono::nanoseconds nsec, const QObject *receiver, const char *member)
void singleShot(std::chrono::nanoseconds nsec, Qt::TimerType timerType, const QObject *receiver, const char *member)

Reimplementierte geschützte Funktionen

virtual void timerEvent(QTimerEvent *e) override

Detaillierte Beschreibung

Die Klasse QTimer bietet eine High-Level-Programmierschnittstelle für Timer. Um sie zu verwenden, erstellen Sie einen QTimer, verbinden sein timeout()-Signal mit den entsprechenden Slots und rufen start() auf. Von da an wird er das Signal timeout() in konstanten Abständen ausgeben.

Beispiel für einen Timer von einer Sekunde (1000 Millisekunden) (aus dem Analog Clock Beispiel):

    QTimer *timer = new QTimer(this);
    connect(timer, &QTimer::timeout, this, QOverload<>::of(&AnalogClock::update));
    timer->start(1000);

Von da an wird der Slot update() jede Sekunde aufgerufen.

Sie können einen Timer so einstellen, dass er nur einmal abläuft, indem Sie setSingleShot(true) aufrufen. Sie können auch die statische Funktion QTimer::singleShot() verwenden, um einen Slot nach einem bestimmten Intervall aufzurufen:

    QTimer::singleShot(200, this, &Foo::updateCaption);

In Multithread-Anwendungen können Sie QTimer in jedem Thread verwenden, der eine Ereignisschleife hat. Um eine Ereignisschleife von einem Nicht-GUI-Thread aus zu starten, verwenden Sie QThread::exec(). Qt verwendet die thread affinity des Timers, um zu bestimmen, welcher Thread das timeout()-Signal ausgeben wird. Aus diesem Grund müssen Sie den Timer in seinem Thread starten und stoppen; es ist nicht möglich, einen Timer von einem anderen Thread aus zu starten.

Als Sonderfall wird ein QTimer mit einem Timeout von 0 so schnell wie möglich ablaufen, obwohl die Reihenfolge zwischen Null-Timern und anderen Ereignisquellen nicht spezifiziert ist. Null-Timer können verwendet werden, um etwas Arbeit zu erledigen und gleichzeitig eine flotte Benutzeroberfläche zu bieten:

    QTimer *timer = new QTimer(this);
    connect(timer, &QTimer::timeout, this, &Foo::processOneThing);
    timer->start();

Von da an wird processOneThing() wiederholt aufgerufen. Er sollte so geschrieben sein, dass er immer schnell zurückkehrt (typischerweise nach der Verarbeitung eines Datenelements), so dass Qt Ereignisse an die Benutzeroberfläche liefern und den Timer stoppen kann, sobald er seine Arbeit erledigt hat. Dies ist der traditionelle Weg, um schwere Arbeit in GUI-Anwendungen zu implementieren, aber da Multithreading heutzutage auf immer mehr Plattformen verfügbar ist, erwarten wir, dass Null-Millisekunden-QTimer-Objekte nach und nach durch QThreadersetzt werden.

Genauigkeit und Timer-Auflösung

Die Genauigkeit von Timern hängt vom zugrunde liegenden Betriebssystem und der Hardware ab. Die meisten Plattformen unterstützen eine Auflösung von 1 Millisekunde, obwohl die Genauigkeit des Zeitgebers in vielen realen Situationen nicht dieser Auflösung entsprechen wird.

Die Genauigkeit hängt auch von timer type ab. Für Qt::PreciseTimer versucht QTimer, die Genauigkeit bei 1 Millisekunde zu halten. Präzise Timer werden auch nie früher als erwartet ablaufen.

Bei den Typen Qt::CoarseTimer und Qt::VeryCoarseTimer kann QTimer früher als erwartet aufwachen, und zwar innerhalb der für diese Typen geltenden Spannen: 5% des Intervalls für Qt::CoarseTimer und 500 ms für Qt::VeryCoarseTimer.

Alle Timer-Typen können später als erwartet ablaufen, wenn das System beschäftigt oder nicht in der Lage ist, die geforderte Genauigkeit zu liefern. In einem solchen Fall einer Zeitüberschreitung gibt Qt timeout() nur einmal aus, auch wenn mehrere Zeitüberschreitungen abgelaufen sind, und setzt dann das ursprüngliche Intervall fort.

Alternativen zu QTimer

Mit Qt 6.8 wurde QChronoTimer eingeführt. Der Hauptunterschied zwischen den beiden Klassen ist, dass QChronoTimer einen größeren Intervallbereich und eine höhere Genauigkeit unterstützt (std::chrono::nanoseconds). Für QTimer beträgt das maximal unterstützte Intervall ±24 Tage, während es für QChronoTimer ±292 Jahre beträgt (weniger Wahrscheinlichkeit eines Intervallüberlaufs bei längeren Intervallen als std::numeric_limits<int>::max()). Wenn Sie nur eine Millisekundenauflösung und einen Bereich von ±24 Tagen benötigen, können Sie weiterhin QTimer verwenden.

Eine andere Alternative ist die Neuimplementierung der Methode QObject::timerEvent() in Ihrer Klasse (die eine Unterklasse von QObject sein muss) und die Verwendung eines der folgenden Ansätze:

  • Verwendung von QBasicTimer, einer leichtgewichtigen Value-Klasse, die eine Timer-ID umhüllt. Sie können den Timer mit QBasicTimer::start() starten und ihn mit QBasicTimer::stop() stoppen. Sie können das Ereignis in Ihrem reimplemneted timerEvent() behandeln.
  • Eine einfachere Methode ist die direkte Manipulation der Timer-IDs. Um den Timer zu starten, rufen Sie QObject::startTimer() auf und speichern die zurückgegebene ID. Um den Timer zu stoppen, rufen Sie QObject::killTimer() auf. Sie können das Ereignis in Ihrem reimplementierten timerEvent() behandeln. Dieser Ansatz ist in der Regel mühsamer als die Verwendung von QBasicTimer.

Ein Nachteil der Verwendung von timerEvent() ist, dass einige High-Level-Funktionen, wie Single-Shot-Timer und Signale, nicht unterstützt werden.

Einige Betriebssysteme beschränken die Anzahl der Timer, die verwendet werden können; Qt versucht, diese Beschränkungen zu umgehen.

Siehe auch QBasicTimer, QTimerEvent, QObject::timerEvent(), Timer, und Analog Clock.

Dokumentation der Eigenschaften

[bindable read-only] active : bool

Hinweis: Diese Eigenschaft unterstützt QProperty Bindungen.

Diese boolesche Eigenschaft ist true, wenn der Timer läuft; andernfalls false.

[bindable] interval : int

Hinweis: Diese Eigenschaft unterstützt QProperty Bindungen.

Diese Eigenschaft enthält das Timeout-Intervall in Millisekunden

Der Standardwert für diese Eigenschaft ist 0. Ein QTimer mit einem Timeout-Intervall von 0 wird beendet, sobald alle Ereignisse in der Ereigniswarteschlange des Fenstersystems verarbeitet wurden.

Das Einstellen des Intervalls eines laufenden Timers ändert das Intervall, stop() und dann start() den Timer und erfasst ein neues id(). Wenn der Timer nicht läuft, wird nur das Intervall geändert.

Siehe auch singleShot.

[read-only] remainingTime : const int

Diese Eigenschaft enthält die verbleibende Zeit in Millisekunden

Gibt den verbleibenden Wert des Zeitgebers in Millisekunden zurück, der bis zur Zeitüberschreitung verbleibt. Ist der Timer inaktiv, ist der zurückgegebene Wert -1. Ist der Timer überfällig, ist der zurückgegebene Wert 0.

Zugriffsfunktionen:

int remainingTime() const

Siehe auch interval.

[bindable] singleShot : bool

Hinweis: Diese Eigenschaft unterstützt QProperty Bindungen.

Diese Eigenschaft gibt an, ob es sich bei dem Timer um einen Single-Shot-Timer handelt.

Ein Single-Shot-Timer wird nur einmal ausgelöst, Nicht-Single-Shot-Timer werden alle interval Millisekunden ausgelöst.

Der Standardwert für diese Eigenschaft ist false.

Siehe auch interval und singleShot().

[bindable] timerType : Qt::TimerType

Hinweis: Diese Eigenschaft unterstützt QProperty Bindungen.

steuert die Genauigkeit des Timers

Der Standardwert für diese Eigenschaft ist Qt::CoarseTimer.

Siehe auch Qt::TimerType.

Dokumentation der Mitgliedsfunktionen

[static] template <typename Duration, typename Functor> void QTimer::singleShot(Duration interval, Functor &&functor)

[static] template <typename Duration, typename Functor> void QTimer::singleShot(Duration interval, Qt::TimerType timerType, Functor &&functor)

[static] template <typename Duration, typename Functor> void QTimer::singleShot(Duration interval, Qt::TimerType timerType, const QObject *context, Functor &&functor)

[static] template <typename Duration, typename Functor> void QTimer::singleShot(Duration interval, const QObject *context, Functor &&functor)

Diese statische Funktion ruft functor nach interval auf.

Es ist sehr praktisch, diese Funktion zu verwenden, da Sie sich nicht um ein timerEvent kümmern oder ein lokales QTimer Objekt erstellen müssen.

Wenn context angegeben ist, wird functor nur aufgerufen, wenn das Objekt context nicht zerstört wurde, bevor das Intervall eintritt. Der Funktor wird dann im Thread von context ausgeführt. Der Thread des Kontexts muss eine laufende Qt-Ereignisschleife haben.

Wenn functor eine Mitgliedsfunktion von context ist, dann wird die Funktion auf dem Objekt aufgerufen.

Der Parameter interval kann ein int (interpretiert als Millisekundenzählung) oder ein std::chrono Typ sein, der implizit in Nanosekunden konvertiert.

Hinweis: In Qt-Versionen vor 6.8 nahmen die chrono-Überladungen chrono::milliseconds, nicht chrono::nanoseconds. Der Compiler konvertiert automatisch für Sie, aber die Konvertierung kann bei extrem großen Millisekundenzahlen zum Überlauf führen.

Hinweis: Diese Funktion ist reentrant.

Siehe auch start().

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

Konstruiert einen Timer mit der angegebenen parent.

[virtual noexcept] QTimer::~QTimer()

Zerstört den Timer.

template <typename Functor> QMetaObject::Connection QTimer::callOnTimeout(Functor &&slot)

Erstellt eine Verbindung vom Signal timeout() des Timers zu slot. Gibt ein Handle für die Verbindung zurück.

Diese Methode wird der Einfachheit halber bereitgestellt. Sie ist äquivalent zum Aufruf:

QObject::connect(timer, &QTimer::timeout, timer, slot, Qt::DirectConnection);

Hinweis: Diese Überladung ist nicht verfügbar, wenn QT_NO_CONTEXTLESS_CONNECT definiert ist. Verwenden Sie stattdessen die Überladung callOnTimeout(), die ein Kontextobjekt annimmt.

Siehe auch QObject::connect() und timeout().

template <typename Functor> QMetaObject::Connection QTimer::callOnTimeout(const QObject *context, Functor &&slot, Qt::ConnectionType connectionType = Qt::AutoConnection)

Diese Funktion überlastet callOnTimeout().

Erstellt eine Verbindung vom Signal timeout() zu slot, die in einer bestimmten Ereignisschleife von context platziert wird, und gibt ein Handle auf die Verbindung zurück.

Diese Methode wird der Einfachheit halber bereitgestellt. Sie ist äquivalent zum Aufruf:

QObject::connect(timer, &QTimer::timeout, context, slot, connectionType);

Siehe auch QObject::connect() und timeout().

[since 6.8] Qt::TimerId QTimer::id() const

Gibt eine Qt::TimerId zurück, die die Timer-ID repräsentiert, wenn der Timer läuft; andernfalls wird Qt::TimerId::Invalid zurückgegeben.

Diese Funktion wurde in Qt 6.8 eingeführt.

Siehe auch Qt::TimerId.

std::chrono::milliseconds QTimer::intervalAsDuration() const

Gibt das Intervall dieses Timers als std::chrono::milliseconds Objekt zurück.

Siehe auch interval.

bool QTimer::isActive() const

Gibt true zurück, wenn der Timer läuft; andernfalls wird false zurückgegeben.

Hinweis: Getter-Funktion für die Eigenschaft active.

std::chrono::milliseconds QTimer::remainingTimeAsDuration() const

Gibt die verbleibende Zeit in diesem Timer-Objekt als std::chrono::milliseconds Objekt zurück. Wenn dieser Timer fällig oder überfällig ist, lautet der zurückgegebene Wert std::chrono::milliseconds::zero(). Wenn die verbleibende Zeit nicht gefunden werden konnte oder der Timer nicht läuft, gibt diese Funktion eine negative Dauer zurück.

Siehe auch remainingTime().

[static] void QTimer::singleShot(std::chrono::nanoseconds nsec, const QObject *receiver, const char *member)

Dies ist eine überladene Funktion.

Diese statische Funktion ruft einen Slot nach einem bestimmten Zeitintervall auf.

Es ist sehr praktisch, diese Funktion zu verwenden, da Sie sich nicht mit einem timerEvent befassen oder ein lokales QTimer Objekt erstellen müssen.

Das receiver ist das empfangende Objekt und das member ist der Slot. Das Zeitintervall wird im duration-Objekt nsec angegeben.

Hinweis: In Qt-Versionen vor 6.8 nahm diese Funktion chrono::milliseconds, nicht chrono::nanoseconds. Der Compiler konvertiert automatisch für Sie, aber die Konvertierung kann bei extrem großen Millisekunden-Zahlen zu einem Überlauf führen.

Hinweis: Diese Funktion ist reentrant.

Siehe auch start().

[static] void QTimer::singleShot(std::chrono::nanoseconds nsec, Qt::TimerType timerType, const QObject *receiver, const char *member)

Dies ist eine überladene Funktion.

Diese statische Funktion ruft einen Slot nach einem bestimmten Zeitintervall auf.

Es ist sehr praktisch, diese Funktion zu verwenden, da Sie sich nicht mit einem timerEvent befassen oder ein lokales QTimer Objekt erstellen müssen.

Das receiver ist das empfangende Objekt und das member ist der Slot. Das Zeitintervall wird im Objekt duration nsec angegeben. Die timerType beeinflusst die Genauigkeit des Timers.

Hinweis: In Qt-Versionen vor 6.8 nahm diese Funktion chrono::milliseconds, nicht chrono::nanoseconds. Der Compiler konvertiert automatisch für Sie, aber die Konvertierung kann bei extrem großen Millisekunden-Zahlen zu einem Überlauf führen.

Hinweis: Diese Funktion ist reentrant.

Siehe auch start().

[slot] void QTimer::start(int msec)

Startet den Timer oder startet ihn neu mit einem Timeout-Intervall von msec Millisekunden.

Wenn der Timer bereits läuft, wird er stopped und neu gestartet. Dadurch wird auch sein id() geändert.

Wenn singleShot true ist, wird der Timer nur einmal aktiviert. Dies ist gleichbedeutend mit:

timer.setInterval(msec);
timer.start();

Hinweis: Die Ereignisschleife mit einem Null-Timer zu beschäftigen, führt zwangsläufig zu Problemen und einem sehr unregelmäßigen Verhalten der Benutzeroberfläche.

[slot] void QTimer::start()

Diese Funktion überlastet start().

Startet den Timer oder startet ihn neu mit der in interval angegebenen Zeitüberschreitung.

Wenn der Timer bereits läuft, wird er stopped und neu gestartet. Dies ändert auch seine id().

Wenn singleShot wahr ist, wird der Timer nur einmal aktiviert.

void QTimer::start(std::chrono::milliseconds msec)

Dies ist eine überladene Funktion.

Startet oder startet den Timer mit einer Zeitüberschreitung der Dauer msec Millisekunden neu.

Wenn der Timer bereits läuft, wird er stopped und neu gestartet. Dadurch wird auch sein id() geändert.

Wenn singleShot true ist, wird der Timer nur einmal aktiviert. Dies ist gleichbedeutend mit:

timer.setInterval(msec);
timer.start();

[slot] void QTimer::stop()

Hält den Timer an.

Siehe auch start().

[private signal] void QTimer::timeout()

Dieses Signal wird ausgesendet, wenn der Timer abgelaufen ist.

Hinweis: Dies ist ein privates Signal. Es kann in Signalverbindungen verwendet werden, aber nicht vom Benutzer ausgegeben werden.

Siehe auch interval, start(), und stop().

[override virtual protected] void QTimer::timerEvent(QTimerEvent *e)

Reimplements: QObject::timerEvent(QTimerEvent *event).

int QTimer::timerId() const

Gibt die ID des Timers zurück, wenn der Timer läuft; andernfalls wird -1 zurückgegeben.

© 2025 The Qt Company Ltd. Documentation contributions included herein are the copyrights of their respective owners. The documentation provided herein is licensed under the terms of the GNU Free Documentation License version 1.3 as published by the Free Software Foundation. Qt and respective logos are trademarks of The Qt Company Ltd. in Finland and/or other countries worldwide. All other trademarks are property of their respective owners.