QElapsedTimer Class
La clase QElapsedTimer ofrece una forma rápida de calcular los tiempos transcurridos. Más información...
| Encabezado: | #include <QElapsedTimer> |
| CMake: | find_package(Qt6 REQUIRED COMPONENTS Core) target_link_libraries(mytarget PRIVATE Qt6::Core) |
| qmake: | QT += core |
Nota: Todas las funciones de esta clase son reentrantes.
Comparaciones de QElapsedTimer
| Categoría | Tipos comparables |
|---|---|
| strong | QElapsedTimer |
Tipos públicos
| enum | ClockType { SystemTime, MonotonicClock, TickCounter, MachAbsoluteTime, PerformanceCounter } |
| Duration | |
| TimePoint |
Funciones públicas
| QElapsedTimer() | |
(since 6.6) QElapsedTimer::Duration | durationElapsed() const |
(since 6.6) QElapsedTimer::Duration | durationTo(const QElapsedTimer &other) const |
| qint64 | elapsed() const |
| bool | hasExpired(qint64 timeout) const |
| void | invalidate() |
| bool | isValid() const |
| qint64 | msecsSinceReference() const |
| qint64 | msecsTo(const QElapsedTimer &other) const |
| qint64 | nsecsElapsed() const |
| qint64 | restart() |
| qint64 | secsTo(const QElapsedTimer &other) const |
| void | start() |
Miembros públicos estáticos
| QElapsedTimer::ClockType | clockType() |
| bool | isMonotonic() |
No miembros relacionados
| bool | operator!=(const QElapsedTimer &lhs, const QElapsedTimer &rhs) |
| bool | operator<(const QElapsedTimer &lhs, const QElapsedTimer &rhs) |
| bool | operator==(const QElapsedTimer &lhs, const QElapsedTimer &rhs) |
Descripción detallada
La clase QElapsedTimer se suele utilizar para calcular rápidamente cuánto tiempo ha transcurrido entre dos eventos. Su API es similar a la de QTime, por lo que el código que la utilizaba se puede adaptar rápidamente a la nueva clase.
Sin embargo, a diferencia de QTime, QElapsedTimer intenta utilizar relojes monótonos siempre que sea posible. Esto significa que no es posible convertir los objetos de QElapsedTimer a un formato de hora legible para las personas.
El caso de uso típico de la clase es determinar cuánto tiempo se ha dedicado a una operación lenta. El ejemplo más sencillo de este tipo de caso es con fines de depuración, como en el siguiente ejemplo:
QElapsedTimer timer;
timer.start();
slowOperation1();
qDebug() << "The slow operation took" << timer.elapsed() << "milliseconds";En este ejemplo, el temporizador se inicia mediante una llamada a ` start()` y el tiempo transcurrido se calcula mediante la función ` elapsed()`.
El tiempo transcurrido también se puede utilizar para recalcular el tiempo disponible para otra operación, una vez finalizada la primera. Esto resulta útil cuando la ejecución debe completarse en un plazo determinado, pero se necesitan varios pasos. Las funciones de tipo ` waitFor` de ` QIODevice ` y sus subclases son buenos ejemplos de esta necesidad. En ese caso, el código podría ser el siguiente:
void executeSlowOperations(int timeout)
{
QElapsedTimer timer;
timer.start();
slowOperation1();
int remainingTime = timeout - timer.elapsed();
if (remainingTime > 0)
slowOperation2(remainingTime);
}Otro caso de uso es ejecutar una operación determinada durante un intervalo de tiempo específico. Para ello, QElapsedTimer proporciona la función de conveniencia hasExpired(), que puede utilizarse para determinar si ya ha transcurrido un número determinado de milisegundos:
void executeOperationsForTime(int ms)
{
QElapsedTimer timer;
timer.start();
while (!timer.hasExpired(ms))
slowOperation1();
}A menudo resulta más práctico utilizar ` QDeadlineTimer ` en este caso, ya que cuenta hacia un tiempo de espera futuro en lugar de realizar un seguimiento del tiempo transcurrido.
Relojes de referencia
QElapsedTimer utilizará el reloj de referencia monótono de la plataforma en todas aquellas que lo admitan (véase QElapsedTimer::isMonotonic()). Esto tiene la ventaja añadida de que QElapsedTimer es inmune a los ajustes de hora, como por ejemplo cuando el usuario corrige la hora. Además, a diferencia de QTime, QElapsedTimer es inmune a los cambios en la configuración de la zona horaria, como los periodos de horario de verano.
Por otro lado, esto significa que los valores de `QElapsedTimer` solo pueden compararse con otros valores que utilicen la misma referencia. Esto es especialmente cierto si el tiempo transcurrido desde la referencia se extrae del objeto QElapsedTimer (QElapsedTimer::msecsSinceReference()) y se serializa. Estos valores nunca deben intercambiarse a través de la red ni guardarse en disco, ya que no se puede saber si el nodo informático que recibe los datos es el mismo que el que los generó o si se ha reiniciado desde entonces.
Sin embargo, sí es posible intercambiar el valor con otros procesos que se ejecuten en la misma máquina, siempre que estos también utilicen el mismo reloj de referencia. QElapsedTimer siempre utilizará el mismo reloj, por lo que es seguro compararlo con el valor procedente de otro proceso de la misma máquina. Si se compara con valores generados por otras API, se debe comprobar que el reloj utilizado sea el mismo que el de QElapsedTimer (véase QElapsedTimer::clockType()).
Véase también QTime, QChronoTimer y QDeadlineTimer.
Documentación sobre los tipos de miembros
enum QElapsedTimer::ClockType
Esta enumeración contiene los distintos tipos de reloj que puede utilizar QElapsedTimer.
QElapsedTimer Siempre se utilizará el mismo tipo de reloj en una máquina concreta, por lo que este valor no cambiará durante la ejecución de un programa. Se proporciona para que QElapsedTimer pueda utilizarse con otras implementaciones que no sean de Qt, con el fin de garantizar que se utilice el mismo reloj de referencia.
| Constante | Valor | Descripción |
|---|---|---|
QElapsedTimer::SystemTime | 0 | La hora del sistema legible para el usuario. Este reloj no es monótono. |
QElapsedTimer::MonotonicClock | 1 | El reloj monótono del sistema, que suele encontrarse en sistemas Unix. Este reloj es monótono. |
QElapsedTimer::TickCounter | 2 | Ya no se utiliza. |
QElapsedTimer::MachAbsoluteTime | 3 | La hora absoluta del núcleo Mach (macOS e iOS). Este reloj es monótono. |
QElapsedTimer::PerformanceCounter | 4 | El contador de rendimiento proporcionado por Windows. Este reloj es monótono. |
SystemTime
El reloj de tiempo del sistema es puramente el tiempo real, expresado en milisegundos desde el 1 de enero de 1970 a las 0:00 UTC. Es equivalente al valor devuelto por la función « time » de C y POSIX, con los milisegundos añadidos. Este tipo de reloj solo se utiliza actualmente en sistemas Unix que no admiten relojes monótonos (véase más abajo).
Este es el único reloj no monotónico que puede utilizar « QElapsedTimer ».
MonotonicClock
Se trata del reloj monotónico del sistema, expresado en milisegundos desde un punto arbitrario en el pasado. Este tipo de reloj se utiliza en sistemas Unix que admiten relojes monotónicos POSIX (_POSIX_MONOTONIC_CLOCK).
MachAbsoluteTime
Este tipo de reloj se basa en el tiempo absoluto que proporcionan los núcleos Mach, como el que se encuentra en macOS. Este tipo de reloj se presenta por separado de MonotonicClock, ya que macOS e iOS también son sistemas Unix y pueden admitir un reloj monotónico POSIX con valores que difieren del tiempo absoluto de Mach.
Este reloj es monotónico.
PerformanceCounter
Este reloj utiliza las funciones de Windows QueryPerformanceCounter y QueryPerformanceFrequency para acceder al contador de rendimiento del sistema.
Este reloj es monotónico.
Véase también clockType() y isMonotonic().
[alias] QElapsedTimer::Duration
Sinónimo de « std::chrono::nanoseconds ».
[alias] QElapsedTimer::TimePoint
Sinónimo de « std::chrono::time_point<std::chrono::steady_clock, Duration> ».
Documentación de la función miembro
[constexpr noexcept default] QElapsedTimer::QElapsedTimer()
Crea un objeto QElapsedTimer no válido. Un temporizador pasa a ser válido una vez que se ha iniciado.
Véase también isValid() y start().
[static noexcept] QElapsedTimer::ClockType QElapsedTimer::clockType()
Devuelve el tipo de reloj que utiliza esta implementación de ` QElapsedTimer `.
Desde Qt 6.6, ` QElapsedTimer ` utiliza ` std::chrono::steady_clock`, por lo que el tipo de reloj es siempre ` MonotonicClock`.
Véase también isMonotonic().
[noexcept, since 6.6] QElapsedTimer::Duration QElapsedTimer::durationElapsed() const
Devuelve un objeto ` std::chrono::nanoseconds ` con el tiempo transcurrido desde la última vez que se inició este ` QElapsedTimer `.
La llamada a esta función sobre un objeto ` QElapsedTimer ` no válido da lugar a un comportamiento indefinido.
En plataformas que no ofrecen resolución en nanosegundos, el valor devuelto será la mejor estimación disponible.
Esta función se introdujo en Qt 6.6.
Véanse también start(), restart(), hasExpired() y invalidate().
[noexcept, since 6.6] QElapsedTimer::Duration QElapsedTimer::durationTo(const QElapsedTimer &other) const
Devuelve la diferencia de tiempo entre este ` QElapsedTimer ` y ` other ` como un ` std::chrono::nanoseconds`. Si ` other ` se inició antes que este objeto, el valor devuelto será negativo. Si se inició después, el valor devuelto será positivo.
El valor devuelto es indefinido si este objeto o other han sido invalidados.
Esta función se introdujo en Qt 6.6.
Véase también secsTo() y elapsed().
[noexcept] qint64 QElapsedTimer::elapsed() const
Devuelve el número de milisegundos transcurridos desde la última vez que se inició este QElapsedTimer.
La llamada a esta función en un ` QElapsedTimer ` no válido da lugar a un comportamiento indefinido.
Véase también start(), restart(), hasExpired(), isValid() y invalidate().
[noexcept] bool QElapsedTimer::hasExpired(qint64 timeout) const
Devuelve ` true ` si ` elapsed()` supera el valor dado ` timeout`; en caso contrario, devuelve ` false`.
Un valor negativo de ` timeout ` se interpreta como infinito, por lo que en este caso se devuelve ` false `. En los demás casos, es equivalente a ` elapsed() > timeout`. Se puede hacer lo mismo con una duración comparando ` durationElapsed()` con un tiempo de espera de duración.
Véase también elapsed() y QDeadlineTimer.
[noexcept] void QElapsedTimer::invalidate()
Marca este objeto ` QElapsedTimer ` como no válido.
Se puede comprobar si un objeto es inválido con isValid(). Los cálculos del tiempo transcurrido desde que los datos son inválidos no están definidos y es probable que den lugar a resultados extraños.
Véase también ` isValid()`, ` start()` y ` restart()`.
[static noexcept] bool QElapsedTimer::isMonotonic()
Devuelve ` true ` si se trata de un reloj monotónico; en caso contrario, devuelve `false`. Consulta la información sobre los diferentes tipos de reloj para saber cuáles son monotónicos.
Desde Qt 6.6, QElapsedTimer utiliza std::chrono::steady_clock, por lo que esta función ahora siempre devuelve «true».
Véase también ` clockType()` y ` QElapsedTimer::ClockType`.
[noexcept] bool QElapsedTimer::isValid() const
Devuelve ` false ` si el temporizador nunca se ha iniciado o no ha sido invalidado mediante una llamada a ` invalidate()`.
Véase también invalidate(), start() y restart().
[noexcept] qint64 QElapsedTimer::msecsSinceReference() const
Devuelve el número de milisegundos transcurridos entre la última vez que se inició este objeto ` QElapsedTimer ` y el inicio de su reloj de referencia.
Este número suele ser arbitrario para todos los relojes, excepto para el reloj de tipo « QElapsedTimer::SystemTime ». Para ese tipo de reloj, este número corresponde al número de milisegundos transcurridos desde el 1 de enero de 1970 a las 0:00 UTC (es decir, es el tiempo Unix expresado en milisegundos).
En las plataformas Linux, Windows y Apple, este valor suele corresponder al tiempo transcurrido desde el arranque del sistema, aunque normalmente no incluye el tiempo que el sistema ha pasado en estados de suspensión.
Véase también clockType() y elapsed().
[noexcept] qint64 QElapsedTimer::msecsTo(const QElapsedTimer &other) const
Devuelve el número de milisegundos transcurridos entre este ` QElapsedTimer ` y ` other`. Si ` other ` se inició antes que este objeto, el valor devuelto será negativo. Si se inició después, el valor devuelto será positivo.
El valor devuelto es indefinido si este objeto o other han sido invalidados.
Véase también secsTo() y elapsed().
[noexcept] qint64 QElapsedTimer::nsecsElapsed() const
Devuelve el número de nanosegundos transcurridos desde la última vez que se inició este QElapsedTimer.
La llamada a esta función en un QElapsedTimer no válido da lugar a un comportamiento indefinido.
En plataformas que no ofrecen resolución en nanosegundos, el valor devuelto será la mejor estimación disponible.
Véanse también start(), restart(), hasExpired() y invalidate().
[noexcept] qint64 QElapsedTimer::restart()
Reinicia el temporizador y devuelve el número de milisegundos transcurridos desde el inicio anterior. Esta función equivale a obtener el tiempo transcurrido con ` elapsed()` y, a continuación, reiniciar el temporizador con ` start()`, pero lo hace en una sola operación, evitando así tener que obtener el valor del reloj dos veces.
La llamada a esta función con un valor de ` QElapsedTimer ` no válido da lugar a un comportamiento indefinido.
El siguiente ejemplo ilustra cómo utilizar esta función para calibrar un parámetro de una operación lenta (por ejemplo, un recuento de iteraciones) de modo que dicha operación tarde al menos 250 milisegundos:
QElapsedTimer timer;
int count = 1;
timer.start();
do {
count *= 2;
slowOperation2(count);
} while (timer.restart() < 250);
return count;Véase también start(), invalidate(), elapsed() y isValid().
[noexcept] qint64 QElapsedTimer::secsTo(const QElapsedTimer &other) const
Devuelve el número de segundos que transcurren entre este objeto ` QElapsedTimer ` y ` other`. Si ` other ` se inició antes que este objeto, el valor devuelto será negativo. Si se inició después, el valor devuelto será positivo.
La llamada a esta función sobre un ` QElapsedTimer ` no válido da lugar a un comportamiento indefinido.
Véanse también msecsTo() y elapsed().
[noexcept] void QElapsedTimer::start()
Inicia este temporizador. Una vez iniciado, se puede consultar el valor del temporizador con elapsed() o msecsSinceReference().
Normalmente, el temporizador se inicia justo antes de una operación que requiere mucho tiempo, como por ejemplo:
QElapsedTimer timer;
timer.start();
slowOperation1();
qDebug() << "The slow operation took" << timer.elapsed() << "milliseconds";Además, al iniciar un temporizador, vuelve a ser válido.
Véase también restart(), invalidate() y elapsed().
Temas relacionados para no socios
[noexcept] bool operator!=(const QElapsedTimer &lhs, const QElapsedTimer &rhs)
Devuelve « true » si « lhs » y « rhs » contienen horas diferentes; en caso contrario, devuelve «false».
[noexcept] bool operator<(const QElapsedTimer &lhs, const QElapsedTimer &rhs)
Devuelve « true » si « lhs » se inició antes que « rhs »; en caso contrario, devuelve «false».
El valor devuelto es indefinido si uno de los dos parámetros no es válido y el otro sí lo es. Sin embargo, dos temporizadores no válidos son iguales, por lo que esta función devolverá «false».
[noexcept] bool operator==(const QElapsedTimer &lhs, const QElapsedTimer &rhs)
Devuelve ` true ` si ` lhs ` y ` rhs ` contienen la misma hora; en caso contrario, devuelve `false`.
© 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.