C++ Academy · Lezione

Punti nel tempo

Rappresentare istanti nel tempo

Punti nel tempo è una lezione C++ Academy gratuita su CoddyKit. Questa è la lezione 2 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento C++ Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso C++ Academy include 4 lezioni in totale.

Che cos'è un punto temporale

Un std::chrono::time_point rappresenta un momento specifico misurato a partire dall'epoca di un orologio. Associa un orologio a una durata trascorsa da quell'epoca.

Viene restituito da clock::now().
Sottraendo due punti temporali si ottiene una durata.

#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

Ogni punto temporale può restituire la distanza dalla propria epoca con time_since_epoch(), che restituisce una durata.

#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;
}

Sottrazione di punti temporali

Sottraendo un punto temporale da un altro si ottiene una durata, cioè il tempo trascorso tra i due momenti.

#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;
}

Aggiunta di una durata

Aggiungendo una durata a un punto temporale si produce un nuovo punto temporale nel futuro (o nel passato, con una sottrazione). È così che si calcolano le scadenze.

#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;
}

Confronto tra punti temporali

I punti temporali dello stesso orologio supportano tutti gli operatori di confronto, consentendo di verificare se un momento precede o segue un altro.

#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;
}

Punti temporali specifici dell'orologio

Un punto temporale è legato al tipo del proprio orologio. Non è possibile confrontare direttamente un punto temporale di system_clock con uno di steady_clock, perché le loro epoche sono diverse.

#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;
}

Conversione in time_t

system_clock::to_time_t trasforma un punto temporale del calendario in un time_t in stile C, che può essere formattato per la visualizzazione.

#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'operazione inversa, system_clock::from_time_t, costruisce un punto temporale a partire da un valore time_t, ad esempio un timestamp memorizzato.

#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;
}

Calcolo di una scadenza

Un modello comune consiste nel catturare now(), aggiungere una durata di timeout e poi confrontare il risultato con un nuovo now() per verificare se la scadenza è trascorsa.

#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;
}

Precisione del punto temporale

La precisione di un punto temporale corrisponde al tipo di durata del suo orologio. È possibile convertire un punto temporale in un'unità meno precisa utilizzando 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;
}

Memorizzazione dei timestamp

Per rendere persistente un momento, lo converta in un conteggio di secondi dall'epoca, memorizzi il valore intero e ricostruisca in seguito il punto temporale quando necessario.

#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;
}

Verifica rapida

Verifichi la Sua comprensione dell'aritmetica dei punti temporali.

Riepilogo

Ha imparato che un time_point:

indica un momento specifico rispetto all'epoca di un orologio
restituisce il proprio offset tramite time_since_epoch()
consente di aggiungere e sottrarre durate e di effettuare confronti
può essere convertito da e verso time_t per la visualizzazione e la memorizzazione

Ora utilizzerà questi strumenti per eseguire benchmark e misurare le prestazioni del codice.

Domande Frequenti

La lezione «Punti nel tempo» è gratuita?

Sì — il testo completo di «Punti nel tempo» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso C++ Academy, passa a CoddyKit PRO. Il corso C++ Academy include 4 lezioni in totale.

Cosa imparerò in «Punti nel tempo»?

Rappresentare istanti nel tempo Eserciti C++ Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare C++ Academy?

Non è richiesta alcuna esperienza precedente. C++ Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 2 di 4.

Quanto tempo richiede la lezione «Punti nel tempo»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione C++ Academy?

Sì. Ogni lezione C++ Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

← Torna a C++ Academy