QElapsedTimer Class

Documentation sur les fonctions membres

[constexpr noexcept] QElapsedTimer::QElapsedTimer()

Construit un QElapsedTimer invalide. Un timer devient valide une fois qu'il a été démarré.

Voir aussi isValid() et start().

[static noexcept] QElapsedTimer::ClockType QElapsedTimer::clockType()

Renvoie le type d'horloge utilisé par l'implémentation de QElapsedTimer.

Depuis Qt 6.6, QElapsedTimer utilise std::chrono::steady_clock, donc le type d'horloge est toujours MonotonicClock.

Voir aussi isMonotonic().

[noexcept, since 6.6] QElapsedTimer::Duration QElapsedTimer::durationElapsed() const

Retourne un std::chrono::nanoseconds avec le temps écoulé depuis le dernier démarrage de ce QElapsedTimer.

L'appel de cette fonction à un QElapsedTimer invalide entraîne un comportement indéfini.

Sur les plates-formes qui n'offrent pas de résolution en nanosecondes, la valeur renvoyée sera la meilleure estimation disponible.

Cette fonction a été introduite dans Qt 6.6.

Voir aussi start(), restart(), hasExpired(), et invalidate().

[noexcept, since 6.6] QElapsedTimer::Duration QElapsedTimer::durationTo(const QElapsedTimer &other) const

Renvoie la différence de temps entre cet objet QElapsedTimer et other sous la forme d'un std::chrono::nanoseconds. Si other a été lancé avant cet objet, la valeur renvoyée sera négative. S'il a été lancé plus tard, la valeur renvoyée sera positive.

La valeur de retour est indéfinie si cet objet ou other ont été invalidés.

Cette fonction a été introduite dans Qt 6.6.

Voir aussi secsTo() et elapsed().

[noexcept] qint64 QElapsedTimer::elapsed() const

Renvoie le nombre de millisecondes écoulées depuis le dernier démarrage de QElapsedTimer.

L'appel de cette fonction à un QElapsedTimer invalide entraîne un comportement indéfini.

Voir aussi start(), restart(), hasExpired(), isValid() et invalidate().

[noexcept] bool QElapsedTimer::hasExpired(qint64 timeout) const

Renvoie true si elapsed() dépasse timeout, sinon false.

Une valeur négative de timeout est interprétée comme infinie, et false est donc renvoyé dans ce cas. Sinon, c'est équivalent à elapsed() > timeout. Vous pouvez faire la même chose pour une durée en comparant durationElapsed() à un délai d'attente de durée.

Voir aussi elapsed() et QDeadlineTimer.

[noexcept] void QElapsedTimer::invalidate()

Marque cet objet QElapsedTimer comme invalide.

Un objet invalide peut être vérifié avec isValid(). Les calculs du temps écoulé depuis les données invalides ne sont pas définis et produiront probablement des résultats étranges.

Voir aussi isValid(), start() et restart().

[static noexcept] bool QElapsedTimer::isMonotonic()

Retourne true s'il s'agit d'une horloge monotone, false sinon. Voir les informations sur les différents types d'horloge pour comprendre lesquels sont monotones.

Depuis Qt 6.6, QElapsedTimer utilise std::chrono::steady_clock, donc cette fonction renvoie toujours true.

Voir aussi clockType() et QElapsedTimer::ClockType.

[noexcept] bool QElapsedTimer::isValid() const

Retourne false si le timer n'a jamais été démarré ou invalidé par un appel à invalidate().

Voir aussi invalidate(), start() et restart().

[noexcept] qint64 QElapsedTimer::msecsSinceReference() const

Renvoie le nombre de millisecondes entre le dernier démarrage de cet objet QElapsedTimer et le démarrage de son horloge de référence.

Ce nombre est généralement arbitraire pour toutes les horloges, à l'exception de l'horloge QElapsedTimer::SystemTime. Pour ce type d'horloge, ce nombre est le nombre de millisecondes depuis le 1er janvier 1970 à 0:00 UTC (c'est-à-dire le temps Unix exprimé en millisecondes).

Sur les plateformes Linux, Windows et Apple, cette valeur correspond généralement au temps écoulé depuis le démarrage du système, bien qu'elle n'inclue généralement pas le temps que le système a passé en état de veille.

Voir également clockType() et elapsed().

[noexcept] qint64 QElapsedTimer::msecsTo(const QElapsedTimer &other) const

Renvoie le nombre de millisecondes entre cet objet QElapsedTimer et other. Si other a été lancé avant cet objet, la valeur renvoyée sera négative. S'il a été démarré plus tard, la valeur retournée sera positive.

La valeur renvoyée est indéfinie si cet objet ou other ont été invalidés.

Voir également secsTo() et elapsed().

[noexcept] qint64 QElapsedTimer::nsecsElapsed() const

Renvoie le nombre de nanosecondes écoulées depuis le dernier démarrage de QElapsedTimer.

L'appel de cette fonction sur un site QElapsedTimer invalide entraîne un comportement indéfini.

Sur les plates-formes qui n'offrent pas de résolution en nanosecondes, la valeur renvoyée sera la meilleure estimation disponible.

Voir aussi start(), restart(), hasExpired() et invalidate().

[noexcept] qint64 QElapsedTimer::restart()

Redémarre la minuterie et renvoie le nombre de millisecondes écoulées depuis le démarrage précédent. Cette fonction est équivalente à l'obtention du temps écoulé avec elapsed() et au redémarrage de la minuterie avec start(), mais elle le fait en une seule opération, ce qui évite d'avoir à obtenir deux fois la valeur de l'horloge.

L'appel de cette fonction sur un site QElapsedTimer invalide entraîne un comportement indéfini.

L'exemple suivant montre comment utiliser cette fonction pour calibrer un paramètre d'une opération lente (par exemple, un nombre d'itérations) afin que cette opération dure au moins 250 millisecondes :

    QElapsedTimer timer;

    int count = 1;
    timer.start();
    do {
        count *= 2;
        slowOperation2(count);
    } while (timer.restart() < 250);

    return count;

Voir également start(), invalidate(), elapsed() et isValid().

[noexcept] qint64 QElapsedTimer::secsTo(const QElapsedTimer &other) const

Renvoie le nombre de secondes entre cet objet QElapsedTimer et other. Si other a été lancé avant cet objet, la valeur renvoyée sera négative. S'il a été lancé plus tard, la valeur renvoyée sera positive.

L'appel de cette fonction sur ou avec un QElapsedTimer invalide entraîne un comportement non défini.

Voir également msecsTo() et elapsed().

[noexcept] void QElapsedTimer::start()

Démarre cette minuterie. Une fois lancée, la valeur de la minuterie peut être vérifiée à l'aide de elapsed() ou msecsSinceReference().

Normalement, une minuterie est lancée juste avant une longue opération, comme par exemple :

    QElapsedTimer timer ; timer.start() ;
    slowOperation1();

    qDebug() << "The slow operation took" << timer.elapsed() << "milliseconds";

En outre, le démarrage d'un minuteur le rend à nouveau valide.

Voir également restart(), invalidate() et elapsed().