En esta página

QDeadlineTimer Class

La clase QDeadlineTimer marca una fecha límite en el futuro. Más información...

Encabezado: #include <QDeadlineTimer>
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.

Comparativas de QDeadlineTimer

CategoríaTipos comparables
fuerteQDeadlineTimer

Tipos públicos

enum class ForeverConstant { Forever }

Funciones públicas

QDeadlineTimer()
QDeadlineTimer(Qt::TimerType timerType)
QDeadlineTimer(QDeadlineTimer::ForeverConstant, Qt::TimerType timerType = Qt::CoarseTimer)
QDeadlineTimer(qint64 msecs, Qt::TimerType type = Qt::CoarseTimer)
QDeadlineTimer(std::chrono::duration<Rep, Period> remaining, Qt::TimerType type = Qt::CoarseTimer)
QDeadlineTimer(std::chrono::time_point<Clock, Duration> deadline, Qt::TimerType type = Qt::CoarseTimer)
qint64 deadline() const
qint64 deadlineNSecs() const
bool hasExpired() const
bool isForever() const
qint64 remainingTime() const
std::chrono::nanoseconds remainingTimeAsDuration() const
qint64 remainingTimeNSecs() const
void setDeadline(qint64 msecs, Qt::TimerType timerType = Qt::CoarseTimer)
void setDeadline(std::chrono::time_point<Clock, Duration> deadline, Qt::TimerType type = Qt::CoarseTimer)
void setPreciseDeadline(qint64 secs, qint64 nsecs = 0, Qt::TimerType timerType = Qt::CoarseTimer)
void setPreciseRemainingTime(qint64 secs, qint64 nsecs = 0, Qt::TimerType timerType = Qt::CoarseTimer)
void setRemainingTime(qint64 msecs, Qt::TimerType timerType = Qt::CoarseTimer)
void setRemainingTime(std::chrono::duration<Rep, Period> remaining, Qt::TimerType type = Qt::CoarseTimer)
void setTimerType(Qt::TimerType timerType)
void swap(QDeadlineTimer &other)
Qt::TimerType timerType() const
QDeadlineTimer &operator+=(qint64 msecs)
QDeadlineTimer &operator-=(qint64 msecs)
QDeadlineTimer &operator=(std::chrono::duration<Rep, Period> remaining)
QDeadlineTimer &operator=(std::chrono::time_point<Clock, Duration> deadline_)

Miembros públicos estáticos

QDeadlineTimer addNSecs(QDeadlineTimer dt, qint64 nsecs)
QDeadlineTimer current(Qt::TimerType timerType = Qt::CoarseTimer)
bool operator!=(const QDeadlineTimer &lhs, const QDeadlineTimer &rhs)
QDeadlineTimer operator+(QDeadlineTimer dt, qint64 msecs)
QDeadlineTimer operator+(qint64 msecs, QDeadlineTimer dt)
QDeadlineTimer operator-(QDeadlineTimer dt, qint64 msecs)
bool operator<(const QDeadlineTimer &lhs, const QDeadlineTimer &rhs)
bool operator<=(const QDeadlineTimer &lhs, const QDeadlineTimer &rhs)
bool operator==(const QDeadlineTimer &lhs, const QDeadlineTimer &rhs)
bool operator>(const QDeadlineTimer &lhs, const QDeadlineTimer &rhs)
bool operator>=(const QDeadlineTimer &lhs, const QDeadlineTimer &rhs)

Descripción detallada

La clase QDeadlineTimer se utiliza habitualmente para calcular plazos futuros y comprobar si el plazo ha vencido. QDeadlineTimer también se puede utilizar para plazos sin vencimiento («para siempre»). Constituye la contrapartida de QElapsedTimer, que calcula cuánto tiempo ha transcurrido desde que se llamó a QElapsedTimer::start().

QDeadlineTimer ofrece una API más cómoda en comparación con ` QElapsedTimer::hasExpired()`.

El caso de uso típico de la clase consiste en crear un QDeadlineTimer antes de iniciar la operación en cuestión y, a continuación, utilizar remainingTime() o hasExpired() para determinar si se debe seguir intentando la operación. Los objetos QDeadlineTimer pueden pasarse a las funciones que se invocan para ejecutar esta operación, de modo que estas sepan cuánto tiempo deben seguir funcionando.

    void executeOperation(int msecs)
    {
        QDeadlineTimer deadline(msecs);
        do {
            if (readFromDevice(deadline.remainingTime()))
                break;
            waitForReadyRead(deadline);
        } while (!deadline.hasExpired());
    }

Muchas funciones de QDeadlineTimer manejan valores de tiempo de espera, todos ellos medidos en milisegundos. Hay dos valores especiales, al igual que en muchas otras funciones de Qt denominadas « waitFor » o similares:

  • 0: no queda tiempo, ha caducado
  • -1: tiempo infinito restante; el temporizador nunca caduca

Relojes de referencia

QDeadlineTimer utilizará el mismo reloj que QElapsedTimer (véase QElapsedTimer::clockType() y QElapsedTimer::isMonotonic()).

Tipos de temporizador

Al igual que QTimer y QChronoTimer, QDeadlineTimer puede seleccionar entre diferentes niveles de precisión en los temporizadores. Se puede seleccionar una temporización precisa pasando Qt::PreciseTimer a las funciones que establecen o modifican el temporizador, o se puede seleccionar una temporización aproximada pasando Qt::CoarseTimer. Actualmente, Qt::VeryCoarseTimer se interpreta de la misma manera que Qt::CoarseTimer.

Esta característica depende de la compatibilidad del sistema operativo: si el SO no admite la funcionalidad de temporizador aproximado, QDeadlineTimer se comportará como si se hubiera pasado Qt::PreciseTimer.

QDeadlineTimer utiliza por defecto Qt::CoarseTimer porque, en los sistemas operativos que admiten temporización aproximada, realizar llamadas de temporización a esa fuente de reloj suele ser mucho más eficiente. El nivel de aproximación depende del sistema operativo, pero debería ser del orden de un par de milisegundos.

std::chrono Compatibilidad

QDeadlineTimer es compatible con la API de ` std::chrono ` de C++11 y puede crearse a partir de objetos ` std::chrono::duration ` y ` std::chrono::time_point `, así como compararse con ellos. Además, es totalmente compatible con los literales de tiempo de C++14, lo que permite escribir código como el siguiente:

    using namespace std::chrono;
    using namespace std::chrono_literals;

    QDeadlineTimer deadline(30s);
    device->waitForReadyRead(deadline);
    if (deadline.remainingTimeAsDuration() > 300ms)
        cleanup();

Como se puede ver en el ejemplo anterior, QDeadlineTimer ofrece una versión con plantillas de remainingTime() y deadline() que se puede utilizar para devolver objetos std::chrono.

Ten en cuenta que la comparación con ` time_point ` no es tan eficiente como la comparación con ` duration`, ya que es posible que QDeadlineTimer tenga que convertir su propia fuente de reloj interna a la fuente de reloj utilizada por el objeto ` time_point `. Ten en cuenta también que, debido a esta conversión, los plazos no serán precisos, por lo que no se espera que el siguiente código dé los mismos resultados:

    using namespace std::chrono;
    using namespace std::chrono_literals;
    auto now = steady_clock::now();
    QDeadlineTimer deadline(now + 1s);
    Q_ASSERT(deadline == now + 1s);

Véase también QTime, QChronoTimer, QElapsedTimer y Qt::TimerType.

Documentación sobre tipos de miembros

enum class QDeadlineTimer::ForeverConstant

ConstanteValorDescripción
QDeadlineTimer::ForeverConstant::Forever0Se utiliza al crear un « QDeadlineTimer » para indicar que el plazo no debe caducar

Documentación de funciones de miembro

[constexpr noexcept default] QDeadlineTimer::QDeadlineTimer()

[explicit constexpr noexcept] QDeadlineTimer::QDeadlineTimer(Qt::TimerType timerType)

Crea un objeto ` QDeadlineTimer ` caducado. Para este objeto, la función ` remainingTime()` devolverá 0. Si no se ha establecido ` timerType `, el objeto utilizará ` coarse ` timer type.

El tipo de temporizador timerType puede ignorarse, ya que el temporizador ya ha caducado. Del mismo modo, con fines de optimización, esta función no intentará obtener la hora actual y utilizará un valor que se sabe que pertenece al pasado. Por lo tanto, deadline() puede devolver un valor inesperado y este objeto no puede utilizarse para calcular cuánto tiempo lleva vencido. Si se requiere esa funcionalidad, utilice QDeadlineTimer::current().

Véase también hasExpired(), remainingTime(), Qt::TimerType y current().

[constexpr noexcept] QDeadlineTimer::QDeadlineTimer(QDeadlineTimer::ForeverConstant, Qt::TimerType timerType = Qt::CoarseTimer)

Los objetos `QDeadlineTimer` creados con ` ForeverConstant ` nunca caducan. Para dichos objetos, ` remainingTime()` devolverá -1, ` deadline()` devolverá el valor máximo y ` isForever()` devolverá «true».

El tipo de temporizador timerType puede ignorarse, ya que el temporizador nunca caducará.

Véanse también ForeverConstant, hasExpired(), isForever(), remainingTime() y timerType().

[explicit noexcept] QDeadlineTimer::QDeadlineTimer(qint64 msecs, Qt::TimerType type = Qt::CoarseTimer)

Crea un objeto QDeadlineTimer con un tiempo de caducidad de ` msecs ` milisegundos a partir del momento de la creación de este objeto, si `msecs` es un valor positivo. Si ` msecs ` es cero, este QDeadlineTimer se marcará como caducado, lo que hará que ` remainingTime()` devuelva cero y que ` deadline()` devuelva un momento indeterminado en el pasado. Si ` msecs ` es negativo, el temporizador se configurará para que nunca caduque, lo que hará que ` remainingTime()` devuelva -1 y que ` deadline()` devuelva el valor máximo.

El objeto QDeadlineTimer se creará con el temporizador especificado type.

Con fines de optimización, si msecs es cero, esta función puede omitir la obtención de la hora actual y, en su lugar, utilizar un valor que se sabe que corresponde a un momento pasado. Si eso ocurre, deadline() puede devolver un valor inesperado y este objeto no podrá utilizarse para calcular cuánto tiempo lleva vencido. Si se requiere esa funcionalidad, utilice QDeadlineTimer::current() y añádale tiempo.

Nota: Antes de Qt 6.6, el único valor que hacía que el temporizador nunca caducara era -1.

Véase también hasExpired(), isForever(), remainingTime() y setRemainingTime().

template <typename Rep, typename Period> QDeadlineTimer::QDeadlineTimer(std::chrono::duration<Rep, Period> remaining, Qt::TimerType type = Qt::CoarseTimer)

Crea un objeto `QDeadlineTimer` con un tiempo restante de ` remaining`. Si ` remaining ` es cero o negativo, este objeto `QDeadlineTimer` se marcará como caducado, mientras que si ` remaining ` es igual a ` duration::max()`, el objeto se configurará para que nunca caduque.

El objeto `QDeadlineTimer` se creará con el temporizador especificado ` type`.

Este constructor puede utilizarse con los literales de tiempo definidos por el usuario de C++14, como en:

    using namespace std::chrono_literals;
    QDeadlineTimer deadline(250ms);

A efectos de optimización, si remaining es cero o negativo, esta función puede omitir la obtención de la hora actual y, en su lugar, utilizar un valor que se sabe que pertenece al pasado. Si eso ocurre, deadline() puede devolver un valor inesperado y este objeto no se podrá utilizar para calcular cuánto tiempo lleva vencido. Si se requiere esa funcionalidad, utilice QDeadlineTimer::current() y añádale tiempo.

Véase también hasExpired(), isForever(), remainingTime() y setRemainingTime().

template <typename Clock, typename Duration = typename Clock::duration> QDeadlineTimer::QDeadlineTimer(std::chrono::time_point<Clock, Duration> deadline, Qt::TimerType type = Qt::CoarseTimer)

Crea un objeto `QDeadlineTimer` con una fecha límite en el momento ` deadline `, convirtiendo la fuente de reloj ` Clock ` a la fuente de reloj interna de Qt (véase QElapsedTimer::clockType()).

Si deadline corresponde a una fecha pasada, este objeto QDeadlineTimer se marca como caducado, mientras que si deadline es igual a Duration::max(), este objeto se marca como «sin caducidad».

El objeto QDeadlineTimer se creará con el temporizador especificado type.

Véanse también hasExpired(), isForever(), remainingTime() y setDeadline().

[static noexcept] QDeadlineTimer QDeadlineTimer::addNSecs(QDeadlineTimer dt, qint64 nsecs)

Devuelve un objeto ` QDeadlineTimer ` cuya fecha límite se amplía en ` nsecs ` nanosegundos respecto a la fecha límite de ` dt`. Si ` dt ` se ha configurado para que nunca caduque, esta función devuelve un objeto ` QDeadlineTimer ` que tampoco caducará.

Nota: si dt se creó como caducado, su fecha límite es indeterminada y añadir un periodo de tiempo puede hacer que deje de estar caducado o no.

[static noexcept] QDeadlineTimer QDeadlineTimer::current(Qt::TimerType timerType = Qt::CoarseTimer)

Devuelve un objeto ` QDeadlineTimer ` que ha caducado, pero que garantiza que contiene la hora actual. Los objetos creados por esta función pueden utilizarse para calcular cuánto tiempo lleva vencido un temporizador, mediante la función ` deadline()`.

El objeto ` QDeadlineTimer ` se creará con el valor especificado de ` timerType`.

[noexcept] qint64 QDeadlineTimer::deadline() const

Devuelve el instante absoluto correspondiente a la fecha límite almacenada en un objeto ` QDeadlineTimer `, calculado en milisegundos con respecto al reloj de referencia, al igual que ` QElapsedTimer::msecsSinceReference()`. El valor corresponderá a un momento pasado si este ` QDeadlineTimer ` ha caducado.

Si este QDeadlineTimer nunca caduca, esta función devuelve std::numeric_limits<qint64>::max().

Esta función se puede utilizar para calcular el tiempo de retraso de un temporizador, restando QDeadlineTimer::current() o QElapsedTimer::msecsSinceReference(), como en el siguiente ejemplo:

    qint64 realTimeLeft = deadline.deadline();
    if (realTimeLeft != (std::numeric_limits<qint64>::max)()) {
        realTimeLeft -= QDeadlineTimer::current().deadline();
        // or:
        //QElapsedTimer timer;
        //timer.start();
        //realTimeLeft -= timer.msecsSinceReference();
    }

Nota: Los temporizadores que se crearon como caducados tienen como fecha límite un momento indeterminado en el pasado, por lo que es posible que el cálculo anterior no funcione.

Véanse también remainingTime(), deadlineNSecs() y setDeadline().

[noexcept] qint64 QDeadlineTimer::deadlineNSecs() const

Devuelve el instante de tiempo absoluto correspondiente a la fecha límite almacenada en un objeto ` QDeadlineTimer `, calculado en nanosegundos con respecto al reloj de referencia, al igual que ` QElapsedTimer::msecsSinceReference()`. El valor corresponderá a un momento pasado si este ` QDeadlineTimer ` ha caducado.

Si este QDeadlineTimer nunca caduca o si el número de nanosegundos hasta la fecha límite no cabe en el tipo de retorno, esta función devuelve std::numeric_limits<qint64>::max().

Esta función se puede utilizar para calcular el tiempo que lleva vencido un temporizador, restando QDeadlineTimer::current(), como en el siguiente ejemplo:

    qint64 realTimeLeft = deadline.deadlineNSecs();
    if (realTimeLeft != std::numeric_limits<qint64>::max())
        realTimeLeft -= QDeadlineTimer::current().deadlineNSecs();

Nota: Los temporizadores que se crearon como caducados tienen como fecha límite un momento indeterminado en el pasado, por lo que es posible que el cálculo anterior no funcione.

Véanse también remainingTime(), deadline() y setDeadline().

[noexcept] bool QDeadlineTimer::hasExpired() const

Devuelve «true» si este objeto « QDeadlineTimer » ha caducado, y «false» si aún le queda tiempo. En el caso de los objetos que han caducado, la función « remainingTime()» devolverá cero y la función « deadline()» devolverá un momento en el pasado.

QDeadlineTimer Los objetos creados con ` ForeverConstant ` nunca caducan y esta función siempre devuelve «false» para ellos.

Véanse también isForever() y remainingTime().

[constexpr noexcept] bool QDeadlineTimer::isForever() const

Devuelve «true» si este objeto ` QDeadlineTimer ` nunca caduca; en caso contrario, devuelve «false». Para los temporizadores que nunca caducan, ` remainingTime()` siempre devuelve -1 y ` deadline()` devuelve el valor máximo.

Véase también ForeverConstant, hasExpired() y remainingTime().

[noexcept] qint64 QDeadlineTimer::remainingTime() const

Devuelve el tiempo restante en este objeto ` QDeadlineTimer ` en milisegundos. Si el temporizador ya ha caducado, esta función devolverá cero y no es posible obtener el tiempo transcurrido con esta función (para ello, véase ` deadline()`). Si el temporizador se configuró para que nunca caducara, esta función devuelve -1.

Esta función es adecuada para su uso en las API de Qt que admiten un tiempo de espera en milisegundos, como muchas de las funciones de QIODevice waitFor o las funciones de bloqueo temporizado de QMutex, QWaitCondition, QSemaphore o QReadWriteLock. Por ejemplo:

    mutex.tryLock(deadline.remainingTime());

Véase también setRemainingTime(), remainingTimeNSecs(), isForever() y hasExpired().

[noexcept] std::chrono::nanoseconds QDeadlineTimer::remainingTimeAsDuration() const

Devuelve el tiempo que queda antes de que finalice el plazo.

[noexcept] qint64 QDeadlineTimer::remainingTimeNSecs() const

Devuelve el tiempo restante en este objeto QDeadlineTimer en nanosegundos. Si el temporizador ya ha caducado, esta función devolverá cero y no es posible obtener el tiempo transcurrido mediante esta función. Si el temporizador se configuró para que nunca caducara, esta función devuelve -1.

Véase también remainingTime(), isForever() y hasExpired().

[noexcept] void QDeadlineTimer::setDeadline(qint64 msecs, Qt::TimerType timerType = Qt::CoarseTimer)

Establece la fecha límite para este objeto ` QDeadlineTimer ` en el punto temporal absoluto ` msecs `, contado en milisegundos desde el reloj de referencia (igual que ` QElapsedTimer::msecsSinceReference()`), y el tipo de temporizador en ` timerType`. Si el valor corresponde a una fecha pasada, este ` QDeadlineTimer ` se marcará como caducado.

Si msecs es std::numeric_limits<qint64>::max() o si la fecha límite se encuentra más allá de un punto representable en el futuro, este QDeadlineTimer se configurará para que nunca caduque.

Véase también setPreciseDeadline(), deadline(), deadlineNSecs() y setRemainingTime().

template <typename Clock, typename Duration = typename Clock::duration> void QDeadlineTimer::setDeadline(std::chrono::time_point<Clock, Duration> deadline, Qt::TimerType type = Qt::CoarseTimer)

Establece este objeto ` QDeadlineTimer ` en la fecha límite indicada por el punto temporal ` deadline `, convirtiendo la fuente de reloj ` Clock ` a la fuente de reloj interna de Qt (véase ` QElapsedTimer::clockType()`).

Si deadline corresponde a una fecha pasada, este objeto QDeadlineTimer se establece como caducado; en cambio, si deadline es igual a Duration::max(), este objeto se establece para que nunca caduque.

El tipo de temporizador de este objeto QDeadlineTimer se establecerá en el valor especificado en type.

Véase también hasExpired(), isForever() y remainingTime().

[noexcept] void QDeadlineTimer::setPreciseDeadline(qint64 secs, qint64 nsecs = 0, Qt::TimerType timerType = Qt::CoarseTimer)

Establece la fecha límite de este objeto QDeadlineTimer en secs segundos y nsecs nanosegundos desde la época del reloj de referencia (igual que QElapsedTimer::msecsSinceReference()), y el tipo de temporizador en timerType. Si el valor corresponde a una fecha pasada, este QDeadlineTimer se marcará como caducado.

Si secs o nsecs es std::numeric_limits<qint64>::max(), este QDeadlineTimer se configurará para que nunca caduque. Si nsecs es superior a 1 000 millones de nanosegundos (1 segundo), entonces secs se ajustará en consecuencia.

Véase también setDeadline(), deadline(), deadlineNSecs() y setRemainingTime().

[noexcept] void QDeadlineTimer::setPreciseRemainingTime(qint64 secs, qint64 nsecs = 0, Qt::TimerType timerType = Qt::CoarseTimer)

Establece el tiempo restante para este objeto QDeadlineTimer en secs segundos más nsecs nanosegundos a partir de ahora, si secs tiene un valor positivo. Si secs es negativo, este QDeadlineTimer se configurará para que nunca caduque (este comportamiento no se aplica a nsecs). Si ambos parámetros son cero, este QDeadlineTimer se marcará como caducado.

Con fines de optimización, si tanto secs como nsecs son cero, esta función puede omitir la obtención de la hora actual y, en su lugar, utilizar un valor que se sabe que pertenece al pasado. Si eso ocurre, deadline() puede devolver un valor inesperado y este objeto no podrá utilizarse para calcular cuánto tiempo lleva vencido. Si se requiere esa funcionalidad, utilice QDeadlineTimer::current() y añádale tiempo.

El tipo de temporizador para este objeto QDeadlineTimer se establecerá en el timerType especificado.

Nota: Antes de Qt 6.6, la única condición que impedía que el temporizador caducara era que secs fuera -1.

Véase también setRemainingTime(), hasExpired(), isForever() y remainingTime().

[noexcept] void QDeadlineTimer::setRemainingTime(qint64 msecs, Qt::TimerType timerType = Qt::CoarseTimer)

Establece el tiempo restante de este objeto QDeadlineTimer en msecs milisegundos a partir de ahora, si msecs tiene un valor positivo. Si msecs es cero, este objeto QDeadlineTimer se marcará como caducado, mientras que un valor negativo hará que nunca caduque.

A efectos de optimización, si msecs es cero, esta función puede omitir la obtención de la hora actual y, en su lugar, utilizar un valor que se sabe que corresponde a un momento pasado. Si eso ocurre, deadline() puede devolver un valor inesperado y este objeto no podrá utilizarse para calcular cuánto tiempo lleva vencido. Si se requiere esa funcionalidad, utilice QDeadlineTimer::current() y añádale tiempo.

El tipo de temporizador para este objeto ` QDeadlineTimer ` se establecerá en el valor especificado de ` timerType`.

Nota: Antes de Qt 6.6, el único valor que hacía que el temporizador nunca caducara era -1.

Véase también setPreciseRemainingTime(), hasExpired(), isForever() y remainingTime().

template <typename Rep, typename Period> void QDeadlineTimer::setRemainingTime(std::chrono::duration<Rep, Period> remaining, Qt::TimerType type = Qt::CoarseTimer)

Establece el tiempo restante de este objeto « QDeadlineTimer » en « remaining ». Si « remaining » es cero o negativo, este objeto « QDeadlineTimer » se marcará como caducado, mientras que si « remaining » es igual a « duration::max() », el objeto se configurará para que nunca caduque.

El tipo de temporizador de este objeto QDeadlineTimer se establecerá en el type especificado.

Esta función se puede utilizar con los literales de tiempo definidos por el usuario de C++14, como en:

    using namespace std::chrono_literals;
    deadline.setRemainingTime(250ms);

Esta es una función sobrecargada.

Véase también setDeadline(), remainingTime(), hasExpired() y isForever().

void QDeadlineTimer::setTimerType(Qt::TimerType timerType)

Cambia el tipo de temporizador de este objeto a « timerType ».

El comportamiento de cada valor posible de « timerType » depende del sistema operativo. « Qt::PreciseTimer » utilizará el temporizador más preciso que Qt pueda encontrar, con una resolución de 1 milisegundo o superior, mientras que « QDeadlineTimer » intentará utilizar un temporizador menos preciso para « Qt::CoarseTimer » y « Qt::VeryCoarseTimer ».

Véase también timerType() y Qt::TimerType.

[noexcept] void QDeadlineTimer::swap(QDeadlineTimer &other)

Sustituye este temporizador por other. Esta operación es muy rápida y nunca falla.

[noexcept] Qt::TimerType QDeadlineTimer::timerType() const

Devuelve el tipo de temporizador que está activo para este objeto.

Véase también setTimerType().

QDeadlineTimer &QDeadlineTimer::operator+=(qint64 msecs)

Amplía este objeto ` QDeadlineTimer ` en ` msecs ` milisegundos y devuelve el propio objeto. Si este objeto está configurado para que nunca caduque, esta función no realiza ninguna acción.

Para añadir tiempos con una precisión superior a 1 milisegundo, utiliza addNSecs().

QDeadlineTimer &QDeadlineTimer::operator-=(qint64 msecs)

Acorta este objeto ` QDeadlineTimer ` en ` msecs ` milisegundos y devuelve el propio objeto. Si este objeto está configurado para que nunca caduque, esta función no realiza ninguna acción.

Para restar tiempos con una precisión superior a 1 milisegundo, utiliza addNSecs().

template <typename Rep, typename Period> QDeadlineTimer &QDeadlineTimer::operator=(std::chrono::duration<Rep, Period> remaining)

Establece el temporizador de este plazo en la hora remaining.

template <typename Clock, typename Duration = typename Clock::duration> QDeadlineTimer &QDeadlineTimer::operator=(std::chrono::time_point<Clock, Duration> deadline_)

Asigna « deadline_ » a este temporizador de plazo.

Personas relacionadas que no son miembros

[noexcept] bool operator!=(const QDeadlineTimer &lhs, const QDeadlineTimer &rhs)

Devuelve «true» si la fecha límite de lhs y la de rhs son diferentes; en caso contrario, devuelve «false». Se ignora el tipo de temporizador utilizado para crear ambas fechas límite. Esta función es equivalente a:

    return lhs.deadlineNSecs() != rhs.deadlineNSecs();

Nota: no se admitela comparación de objetos de QDeadlineTimer con tipos de temporizador diferentes, ya que puede dar lugar a un comportamiento impredecible.

QDeadlineTimer operator+(QDeadlineTimer dt, qint64 msecs)

Devuelve un objeto ` QDeadlineTimer ` cuya fecha límite, ` msecs `, es posterior a la fecha límite almacenada en ` dt`. Si ` dt ` está configurado para que nunca caduque, esta función devuelve un objeto ` QDeadlineTimer ` que tampoco caduca.

Para añadir tiempos con una precisión superior a 1 milisegundo, utiliza addNSecs().

QDeadlineTimer operator+(qint64 msecs, QDeadlineTimer dt)

Devuelve un objeto ` QDeadlineTimer ` cuyo plazo de vencimiento es ` msecs `, posterior al plazo almacenado en ` dt`. Si ` dt ` está configurado para que nunca caduque, esta función devuelve un ` QDeadlineTimer ` que tampoco caduca.

Para añadir tiempos con una precisión superior a 1 milisegundo, utiliza addNSecs().

QDeadlineTimer operator-(QDeadlineTimer dt, qint64 msecs)

Devuelve un objeto ` QDeadlineTimer ` cuya fecha límite es ` msecs ` antes de la fecha límite almacenada en ` dt`. Si ` dt ` está configurado para que nunca caduque, esta función devuelve un objeto ` QDeadlineTimer ` que tampoco caduca.

Para restar tiempos con una precisión superior a 1 milisegundo, utiliza addNSecs().

[noexcept] bool operator<(const QDeadlineTimer &lhs, const QDeadlineTimer &rhs)

Devuelve «true» si la fecha límite de lhs es anterior a la de rhs; en caso contrario, devuelve «false». Se ignora el tipo de temporizador utilizado para crear las dos fechas límite. Esta función es equivalente a:

    return lhs.deadlineNSecs() < rhs.deadlineNSecs();

Nota: no se admitela comparación de objetos ` QDeadlineTimer ` con tipos de temporizador diferentes, ya que puede dar lugar a un comportamiento impredecible.

[noexcept] bool operator<=(const QDeadlineTimer &lhs, const QDeadlineTimer &rhs)

Devuelve «true» si la fecha límite de lhs es anterior o igual a la de rhs; en caso contrario, devuelve «false». Se ignora el tipo de temporizador utilizado para crear las dos fechas límite. Esta función es equivalente a:

    return lhs.deadlineNSecs() <= rhs.deadlineNSecs();

Nota: no se admitela comparación de objetos de QDeadlineTimer con tipos de temporizador diferentes, ya que puede dar lugar a un comportamiento impredecible.

[noexcept] bool operator==(const QDeadlineTimer &lhs, const QDeadlineTimer &rhs)

Devuelve «true» si la fecha límite de lhs y la de rhs coinciden; en caso contrario, devuelve «false». Se ignora el tipo de temporizador utilizado para crear ambas fechas límite. Esta función es equivalente a:

    return lhs.deadlineNSecs() == rhs.deadlineNSecs();

Nota: no se admitela comparación de objetos ` QDeadlineTimer ` con tipos de temporizador diferentes, ya que puede dar lugar a un comportamiento impredecible.

[noexcept] bool operator>(const QDeadlineTimer &lhs, const QDeadlineTimer &rhs)

Devuelve «true» si la fecha límite de lhs es posterior a la de rhs; en caso contrario, devuelve «false». Se ignora el tipo de temporizador utilizado para crear las dos fechas límite. Esta función es equivalente a:

    return lhs.deadlineNSecs() > rhs.deadlineNSecs();

Nota: no se admitela comparación de objetos ` QDeadlineTimer ` con tipos de temporizador diferentes, ya que puede dar lugar a un comportamiento impredecible.

[noexcept] bool operator>=(const QDeadlineTimer &lhs, const QDeadlineTimer &rhs)

Devuelve «true» si la fecha límite de lhs es posterior o igual a la de rhs; en caso contrario, devuelve «false». Se ignora el tipo de temporizador utilizado para crear ambas fechas límite. Esta función es equivalente a:

    return lhs.deadlineNSecs() >= rhs.deadlineNSecs();

Nota: no se admitela comparación de objetos de QDeadlineTimer con tipos de temporizador diferentes, ya que puede dar lugar a un comportamiento impredecible.

© 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.