QChronoTimer Class
La clase QChronoTimer ofrece temporizadores recurrentes y de una sola vez. Más información...
| Encabezado: | #include <QChronoTimer> |
| CMake: | find_package(Qt6 REQUIRED COMPONENTS Core) target_link_libraries(mytarget PRIVATE Qt6::Core) |
| qmake: | QT += core |
| Desde: | Qt 6.8 |
| Heredado de: | QObject |
- Lista de todos los miembros, incluidos los heredados
- QChronoTimer forma parte de las clases de eventos.
Propiedades
|
|
Funciones públicas
| QChronoTimer(QObject *parent = nullptr) | |
| QChronoTimer(std::chrono::nanoseconds nsec, QObject *parent = nullptr) | |
| virtual | ~QChronoTimer() override |
| QBindable<bool> | bindableActive() |
| QBindable<std::chrono::nanoseconds> | bindableInterval() |
| QBindable<bool> | bindableSingleShot() |
| QBindable<Qt::TimerType> | bindableTimerType() |
| QMetaObject::Connection | callOnTimeout(const QObject *context, Functor &&slot, Qt::ConnectionType connectionType = Qt::AutoConnection) |
| Qt::TimerId | id() const |
| std::chrono::nanoseconds | interval() const |
| bool | isActive() const |
| bool | isSingleShot() const |
| std::chrono::nanoseconds | remainingTime() const |
| void | setInterval(std::chrono::nanoseconds nsec) |
| void | setSingleShot(bool singleShot) |
| void | setTimerType(Qt::TimerType atype) |
| Qt::TimerType | timerType() const |
Ranuras públicas
Señales
| void | timeout() |
Funciones protegidas reimplementadas
| virtual void | timerEvent(QTimerEvent *e) override |
Descripción detallada
La clase QChronoTimer proporciona una interfaz de programación de alto nivel para temporizadores. Para utilizarla, cree un QChronoTimer, ya sea pasando el intervalo al constructor o estableciéndolo tras la creación mediante ` setInterval()`, conecte su señal ` timeout()` a las ranuras adecuadas y llame a ` start()`. A partir de ese momento, emitirá la señal timeout() a intervalos constantes. Por ejemplo:
auto *timer = new QChronoTimer(1s, this);
connect(timer, &QChronoTimer::timeout, this, &MyWidget::processOneThing);
timer->start();
QChronoTimer *timer = new QChronoTimer(this);
connect(timer, &QChronoTimer::timeout, this, &MyWidget::processOneThing);
timer->setInterval(1s);
timer->start();Puedes configurar un temporizador para que expire solo una vez llamando a setSingleShot(true).
Nota: QChronoTimer no dispone de métodos estáticos singleShot(), ya que los de QTimer ya funcionan con tipos chrono y resolución en nanosegundos.
En aplicaciones multihilo, puedes utilizar QChronoTimer en cualquier hilo que tenga un bucle de eventos. Para iniciar un bucle de eventos desde un hilo que no sea de la interfaz gráfica de usuario, utiliza QThread::exec(). Qt utiliza el parámetro « thread affinity » del temporizador para determinar qué hilo emitirá la señal « timeout()». Por este motivo, debes iniciar y detener el temporizador en su propio hilo; no es posible iniciar un temporizador desde otro hilo.
Como caso especial, un QChronoTimer con un tiempo de espera de 0ns agotará su tiempo de espera lo antes posible, aunque el orden entre los temporizadores de tiempo cero y otras fuentes de eventos no está especificado. Los temporizadores de tiempo cero se pueden utilizar para realizar alguna tarea sin dejar de ofrecer una interfaz de usuario con buena capacidad de respuesta:
// The default interval is 0ns
QTimer *timer = new QTimer(this);
connect(timer, &QTimer::timeout, this, &MyWidget::processOneThing);
timer->start();A partir de ese momento, se llamará repetidamente a ` processOneThing() `. Debe escribirse de tal forma que siempre devuelva un resultado rápidamente (por ejemplo, tras procesar un elemento de datos), de modo que Qt pueda enviar eventos a la interfaz de usuario y detener el temporizador tan pronto como haya completado todo su trabajo. Esta es la forma tradicional de implementar tareas pesadas en aplicaciones GUI, pero, dado que el multihilo está cada vez más disponible en más plataformas, una alternativa moderna consiste en realizar las tareas pesadas en un hilo distinto al hilo de la GUI (el hilo principal). Qt dispone de la clase ` QThread `, que puede utilizarse para lograrlo.
Precisión y resolución del temporizador
La precisión de los temporizadores depende del sistema operativo y del hardware subyacentes. La mayoría de las plataformas admiten solicitar una precisión de nanosegundos para los temporizadores (por ejemplo, ` nanosleep` de libc), aunque la precisión del temporizador no igualará esta resolución en muchas situaciones reales.
Puedes configurar ` timer type ` para indicar a QChronoTimer qué precisión debe solicitar al sistema.
Para el valor « Qt::PreciseTimer », QChronoTimer intentará mantener la precisión en « 1ns ». Los temporizadores precisos nunca agotarán el tiempo de espera antes de lo esperado.
Para los tipos « Qt::CoarseTimer » y « Qt::VeryCoarseTimer », QChronoTimer puede activarse antes de lo esperado, dentro de los márgenes establecidos para dichos tipos:
- el 5 % del intervalo para Qt::CoarseTimer
500mspara Qt::VeryCoarseTimer
Todos los tipos de temporizador pueden agotarse más tarde de lo esperado si el sistema está ocupado o no puede proporcionar la precisión solicitada. En tal caso de sobrepaso del tiempo de espera, Qt emitirá timeout() solo una vez, incluso si han expirado varios tiempos de espera, y luego reanudará el intervalo original.
Alternativas a QChronoTimer
QChronoTimer ofrece una resolución de nanosegundos y un rango de ±292 años (menor probabilidad de desbordamiento de enteros si el intervalo es mayor que std::numeric_limits<int>::max()). Si solo necesitas una resolución de milisegundos y un rango de ±24 días, puedes seguir utilizando la clase clásica QTimer
Otra alternativa es reimplementar el método QObject::timerEvent() en tu clase (que debe ser una subclase de QObject) y utilizar uno de los siguientes enfoques:
- Utilizar ` QBasicTimer`, una clase de valor ligera que envuelve un identificador de temporizador. Puedes iniciar el temporizador con ` QBasicTimer::start()` y detenerlo con ` QBasicTimer::stop()`. Puedes gestionar el evento en tu método ` timerEvent()` reimplementado.
- timerEventUn método de nivel más bajo consiste en manipular directamente los ID de los temporizadores. Para iniciar el temporizador, llama a ` QObject::startTimer()`, almacenando el ID devuelto. Para detenerlo, llama a ` QObject::killTimer()`. Puedes gestionar el evento en tu implementación personalizada de ` QBasicTimer()`. Este enfoque suele ser más engorroso que utilizar ` `.
Una desventaja de utilizar ` timerEvent()` es que algunas funciones de alto nivel, como los temporizadores de un solo disparo y las señales, no son compatibles.
Algunos sistemas operativos limitan el número de temporizadores que se pueden utilizar; Qt hace todo lo posible por sortear estas limitaciones.
Véase también QBasicTimer, QTimerEvent, QObject::timerEvent(), Temporizadores y Reloj analógico.
Documentación de propiedades
[bindable read-only] active : bool
Nota: Esta propiedad admite enlaces de tipo « QProperty ».
Esta propiedad booleana es « true » si el temporizador está en marcha; en caso contrario, es « false ».
Funciones de acceso:
| bool | isActive() const |
[bindable] interval : std::chrono::nanoseconds
Nota: Esta propiedad admite enlaces de tipo « QProperty ».
Esta propiedad contiene el intervalo de tiempo de espera
El valor por defecto de esta propiedad es 0ns.
Un ` QChronoTimer ` con un tiempo de espera de ` 0ns ` se agotará tan pronto como se hayan procesado todos los eventos de la cola de eventos del sistema de ventanas.
Al establecer el intervalo de un temporizador en ejecución, se modificará el intervalo ( stop()), se reiniciará el temporizador ( start()) y se obtendrá un nuevo id(). Si el temporizador no está en ejecución, solo se modificará el intervalo.
A partir de Qt 6.10, establecer un intervalo negativo provocará una advertencia en tiempo de ejecución y el valor se restablecerá a 1 ms. Antes de Qt 6.10, un temporizador de Qt permitía establecer un intervalo negativo, pero se comportaba de forma impredecible (por ejemplo, detenía el temporizador si estaba en marcha o no lo iniciaba en absoluto).
Funciones de acceso:
| std::chrono::nanoseconds | interval() const |
| void | setInterval(std::chrono::nanoseconds nsec) |
Véase también singleShot.
[read-only] remainingTime : std::chrono::nanoseconds
Esta propiedad contiene el tiempo restante
Devuelve la duración restante hasta que se agote el tiempo de espera.
Si el temporizador está inactivo, la duración devuelta será negativa.
Si el temporizador ha caducado, la duración devuelta será 0ns.
Funciones de acceso:
| std::chrono::nanoseconds | remainingTime() const |
Véase también « interval ».
[bindable] singleShot : bool
Nota: Esta propiedad admite enlaces de tipo « QProperty ».
Esta propiedad indica si el temporizador es de un solo disparo
Un temporizador de un solo disparo se activa solo una vez, mientras que los temporizadores que no son de un solo disparo se activan cada interval.
El valor predeterminado de esta propiedad es « false ».
Funciones de acceso:
| bool | isSingleShot() const |
| void | setSingleShot(bool singleShot) |
Véase también « interval ».
[bindable] timerType : Qt::TimerType
Nota: Esta propiedad admite enlaces de tipo « QProperty ».
Controla la precisión del temporizador
El valor predeterminado de esta propiedad es ` Qt::CoarseTimer`.
Funciones de acceso:
| Qt::TimerType | timerType() const |
| void | setTimerType(Qt::TimerType atype) |
Véase también Qt::TimerType.
Documentación de funciones de miembro
[explicit] QChronoTimer::QChronoTimer(QObject *parent = nullptr)
Crea un temporizador con el ` parent` indicado, utilizando el intervalo por defecto, ` 0ns`.
[explicit] QChronoTimer::QChronoTimer(std::chrono::nanoseconds nsec, QObject *parent = nullptr)
Crea un temporizador con el valor dado parent, utilizando un intervalo de nsec.
[override virtual noexcept] QChronoTimer::~QChronoTimer()
Elimina el temporizador.
template <typename Functor> QMetaObject::Connection QChronoTimer::callOnTimeout(const QObject *context, Functor &&slot, Qt::ConnectionType connectionType = Qt::AutoConnection)
Crea una conexión desde la señal « timeout()» a « slot » para colocarla en un bucle de eventos específico de « context », con el tipo de conexión « connectionType », y devuelve un identificador de la conexión.
Este método se proporciona para mayor comodidad. Es equivalente a llamar a:
QObject::connect(timer, &QChronoTimer::timeout, context, slot, connectionType);Véase también QObject::connect() y timeout().
Qt::TimerId QChronoTimer::id() const
Devuelve un objeto ` Qt::TimerId ` que representa el ID del temporizador si este está en marcha; en caso contrario, devuelve ` Qt::TimerId::Invalid`.
Véase también Qt::TimerId.
bool QChronoTimer::isActive() const
Devuelve ` true ` si el temporizador está en marcha; en caso contrario, devuelve ` false`.
Nota: Funcióngetter para la propiedad active.
[slot] void QChronoTimer::start()
Inicia o reinicia el temporizador con el tiempo de espera especificado en « interval ».
Si el temporizador ya está en marcha, se pondrá en « stopped » y se reiniciará. Esto también modificará su ` id()`.
Si singleShot es verdadero, el temporizador solo se activará una vez.
[slot] void QChronoTimer::stop()
Detiene el temporizador.
Véase también start().
[private signal] void QChronoTimer::timeout()
Esta señal se emite cuando se agota el tiempo del temporizador.
Nota: Se trata de una señal privada. Se puede utilizar en conexiones de señales, pero el usuario no puede emitirla.
Véase también interval, start() y stop().
[override virtual protected] void QChronoTimer::timerEvent(QTimerEvent *e)
Reimplementa: ` QObject::timerEvent(QTimerEvent *event)`.
© 2026 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.