C++ Academy · Leçon

Points temporels

Représenter des instants

Points temporels est une leçon C++ Academy gratuite sur CoddyKit. Ceci est la leçon 2 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage C++ Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours C++ Academy comprend 4 leçons au total.

Qu’est-ce qu’un point temporel ?

Un std::chrono::time_point représente un instant précis mesuré depuis l’époque d’une horloge. Il associe une horloge à une durée écoulée depuis cette époque.

Il est renvoyé par clock::now().
Soustraire deux points temporels produit une durée.

#include <iostream>
#include <chrono>

int main() {
    using namespace std::chrono;
    time_point<steady_clock> tp = steady_clock::now();
    std::cout << "Captured a moment: " << (tp.time_since_epoch().count() != 0) << '\n';
    return 0;
}

time_since_epoch

Chaque point temporel peut indiquer sa distance par rapport à l’époque de l’horloge avec time_since_epoch(), qui renvoie une durée.

#include <iostream>
#include <chrono>

int main() {
    using namespace std::chrono;
    auto tp = system_clock::now();
    auto d = tp.time_since_epoch();
    auto s = duration_cast<seconds>(d);
    std::cout << "Positive epoch seconds: " << (s.count() > 0) << '\n';
    return 0;
}

Soustraire des points temporels

Soustraire un point temporel d’un autre produit une durée, c’est-à-dire le temps écoulé entre les deux instants.

#include <iostream>
#include <chrono>

int main() {
    using namespace std::chrono;
    auto a = steady_clock::now();
    auto b = steady_clock::now();
    auto diff = b - a;
    std::cout << "Elapsed ns is non-negative: " << (diff.count() >= 0) << '\n';
    return 0;
}

Ajouter une durée

Ajouter une durée à un point temporel produit un nouveau point temporel dans le futur (ou dans le passé en cas de soustraction). C’est ainsi que vous calculez des échéances.

#include <iostream>
#include <chrono>

int main() {
    using namespace std::chrono;
    using namespace std::chrono_literals;
    auto now = steady_clock::now();
    auto deadline = now + 10s;
    std::cout << "Deadline is after now: " << std::boolalpha << (deadline > now) << '\n';
    return 0;
}

Comparer des points temporels

Les points temporels issus de la même horloge prennent en charge tous les opérateurs de comparaison, ce qui vous permet de vérifier si un instant précède ou suit un autre.

#include <iostream>
#include <chrono>

int main() {
    using namespace std::chrono;
    auto first = steady_clock::now();
    auto second = steady_clock::now();
    std::cout << std::boolalpha << (first <= second) << '\n';
    return 0;
}

Points temporels propres à une horloge

Un point temporel est lié au type de son horloge. Vous ne pouvez pas comparer directement un point temporel de system_clock avec un point temporel de steady_clock, car leurs époques diffèrent.

#include <iostream>
#include <chrono>

int main() {
    using namespace std::chrono;
    system_clock::time_point sys = system_clock::now();
    steady_clock::time_point mono = steady_clock::now();
    std::cout << "Both captured: " << ((sys.time_since_epoch().count() != 0) && (mono.time_since_epoch().count() != 0)) << '\n';
    return 0;
}

Conversion vers time_t

system_clock::to_time_t transforme un point temporel calendaire en un time_t de style C que vous pouvez formater pour l’afficher à l’écran.

#include <iostream>
#include <chrono>
#include <ctime>

int main() {
    using namespace std::chrono;
    auto tp = system_clock::now();
    std::time_t t = system_clock::to_time_t(tp);
    std::cout << "time_t is positive: " << (t > 0) << '\n';
    return 0;
}

from_time_t

L’opération inverse, system_clock::from_time_t, construit un point temporel à partir d’une valeur time_t, par exemple un horodatage enregistré.

#include <iostream>
#include <chrono>
#include <ctime>

int main() {
    using namespace std::chrono;
    std::time_t t = 1000000000;
    auto tp = system_clock::from_time_t(t);
    auto back = system_clock::to_time_t(tp);
    std::cout << "Round trip ok: " << std::boolalpha << (back == t) << '\n';
    return 0;
}

Calculer une échéance

Schéma courant : capturez now(), ajoutez une durée de timeout, puis comparez-la plus tard à un nouvel appel de now() pour vérifier si l’échéance est dépassée.

#include <iostream>
#include <chrono>

int main() {
    using namespace std::chrono;
    using namespace std::chrono_literals;
    auto deadline = steady_clock::now() + 0ms;
    auto current = steady_clock::now();
    bool expired = current >= deadline;
    std::cout << "Expired: " << std::boolalpha << expired << '\n';
    return 0;
}

Précision des points temporels

La précision d’un point temporel correspond au type de durée de son horloge. Vous pouvez convertir un point temporel vers une unité plus grossière avec time_point_cast.

#include <iostream>
#include <chrono>

int main() {
    using namespace std::chrono;
    auto tp = system_clock::now();
    auto secs_tp = time_point_cast<seconds>(tp);
    std::cout << "Cast preserved sign: " << (secs_tp.time_since_epoch().count() > 0) << '\n';
    return 0;
}

Enregistrer des horodatages

Pour conserver un instant, convertissez-le en un nombre de secondes depuis l’époque, enregistrez l’entier, puis reconstruisez le point temporel ultérieurement lorsque nécessaire.

#include <iostream>
#include <chrono>

int main() {
    using namespace std::chrono;
    auto tp = system_clock::now();
    long long stored = duration_cast<seconds>(tp.time_since_epoch()).count();
    std::cout << "Stored value usable: " << (stored > 0) << '\n';
    return 0;
}

Vérification rapide

Testez votre compréhension de l’arithmétique des points temporels.

Récapitulatif

Vous avez appris qu’un time_point :

marque un instant précis par rapport à l’époque d’une horloge
indique son décalage avec time_since_epoch()
permet d’ajouter ou de soustraire des durées et d’effectuer des comparaisons
se convertit vers et depuis time_t pour l’affichage et le stockage

Ensuite, vous utiliserez ces outils pour analyser et mesurer les performances du code.

Questions Fréquemment Posées

La leçon « Points temporels » est-elle gratuite ?

Oui — le texte complet de « Points temporels » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours C++ Academy, passe à CoddyKit PRO. Le cours C++ Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Points temporels » ?

Représenter des instants Tu pratiques C++ Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer C++ Academy ?

Aucune expérience préalable n'est requise. C++ Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 2 sur 4.

Combien de temps prend la leçon « Points temporels » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon C++ Academy ?

Oui. Chaque leçon C++ Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

← Retour à C++ Academy